* vs ** aanwijzer in C

* vs ** aanwijzer in C

In dit artikel hebben we het verschil tussen * en ** pointer in C en C++ uitgelegd.

Inhoudsopgave:

1. Wat zijn aanwijzers?

2. Voorbeelden van aanwijzer

3. Implementatie van Pointers met C

4. *p vs **p aanwijzer

5. Implementatie van *p en **p met behulp van C

Wat zijn Pointers?

Pointer is een variabele die wordt gebruikt om het adres in het geheugen van een andere variabele op te slaan.
De twee operatoren die in de aanwijzers worden gebruikt:

  • Operator &:- Geeft het adres van een variabele
  • Operator * :- Geeft de waarden op locatie

Enkele punten:

  • Adres mag niet negatief zijn.
  • Aanwijzervariabele neemt dezelfde bytes geheugen in beslag, ongeacht het gegevenstype.
  • De grootte van de aanwijzervariabele verschilt van systeem tot systeem, afhankelijk van het besturingssysteem.
  • Aanwijzervariabele kan verwijzen naar nr. van bytes, afhankelijk van het gegevenstype.
    * Integer-aanwijzer kan twee bytes aan gegevens derefereren.
    * Karakteraanwijzer heeft toegang tot één byte aan gegevens.
    * Zwevende aanwijzer heeft toegang tot vier bytes aan gegevens.
  • Aanwijzervariabele wordt gedeclareerd met '*'(sterretje).

Voorbeelden van aanwijzer:

int * p ;         // Declaration of pointer ‘p’  
int a = 10 ;  
p = &a ;          //Assigning 
                  //now pointer ‘p’ is pointing at variable ‘a’.  

Hier zijn we aan het declareren en toewijzen van geheugenblok 'a' aan een pointer 'p'.

  • 'p' is de pointervariabele van het type integer waar we het adres van elke integervariabele kunnen opslaan.
  • 'a' is een integer-variabele die waarde 10 opslaat.
int * p ; 
int a = 10 , b ;  
b = &a ;          //ERROR

Hier zien we een fout omdat we proberen het adres van een geheel getal 'a' op te slaan in een ander geheel getal 'b'

int a = 10 ;
printf(" a = %d " , * &a );   // output will be a = 10 

Hier drukken we de waarde van 'a' af door deze als een aanwijzer weer te geven. Zeg gewoon, a=``*&a .

int * p ; 
int a = 10 ;  
p = &a ;  
printf(" %d " , a * p ) ;   // ERROR

printf(" %d " , a * * p );  // No ERROR

Hier zien we een FOUT, omdat 'a' een waarde(=10) heeft en *p heeft ook een waarde(=10) maar de compiler zal in de war raken wat we willen doen omdat de compiler het ziet als printf(" %d ", (a) (*p ) ); , er zijn geen rekenkundige operatoren voor de compiler.
Maar in de volgende printf()-instructie zien we geen FOUT omdat de compiler nu uitvoer als 100 zal geven terwijl we doen Vermenigvuldiging van 'a' en *p en ze bevatten allebei waarde(=10) erin.

Implementatie van Pointers met C

#include<stdio.h>
int main(){
  int a=10;
  int * p = &a ;
  printf("  a = %d \n " , * p ) ;   // It gives output a = 10
  printf(" Address of a = %p \n ", p ) ;  // It gives output Address of a
  printf(" Address of p = %p \n ", & p ) ; // It gives output Address of p
return 0;
}

Hier drukken we de waarde van 'a' en adres van 'a' en 'p' af.

Uitvoer:

  a = 10
  Address of a = 000000000061FE1C
  Address of p = 000000000061FE10

*p vs **p aanwijzer

*p is een aanwijzer, betekent dat het een adres van een waarde of een blok gereserveerd geheugen bevat, het heeft toegang tot één niveau.
Het wordt gebruikt als u een geheugenblok wilt behouden waarin uw waarden zich bevinden.

**p is een aanwijzer naar een aanwijzer, wat betekent dat het een adres bevat dat een adres van een waarde of een blok gereserveerd geheugen bevat. Het heeft toegang tot maximaal twee niveaus.
Het wordt gebruikt als u een aanwijzer wilt doorgeven waarvan het geheugen in een andere functie wordt toegewezen.

  #include<stdio.h>
  int main(){
  int a=10;
  int * p = & a ;              // b is a single pointer or a pointer
  int ** c = &p;         // c is a double pointer or pointer to a pointer 
  printf("using p \n ");
  printf(" value of a = %d \n " , * p ) ;  // It gives output value of a = 10
  printf(" Address of a = %p \n ", p ) ;    // It gives output Address of a
  printf(" Address of p = %p \n", & p ) ;  // It gives output Address of p
  printf("using c \n ");
  printf(" value of a = %d \n ", ** c ) ;    //  It gives output value of a
  printf(" Address of a = %p \n ", * c ) ;   // It gives output Address of a
  printf(" Address of c = %p \n ", &c ) ;   // It gives output Address of c
  printf(" Address of p = %p \n ",  c ) ;   // It gives output Address of p
  return 0;
  }

Hier drukken we de waarden en adressen af ​​met een aanwijzer en een dubbele aanwijzer.

Uitvoer:

using p
value of a = 10
Address of a = 000000000061FE1C
Address of p = 000000000061FE10
using c
value of a = 10
Address of a = 000000000061FE1C
Address of c = 000000000061FE08
Address of p = 000000000061FE10

Implementatie van *p en **p met behulp van C

#include<stdio.h>
void swap(int * x ,int * y ){
int t = * x ;
 * x = * y ;
 * y = t ;
}
int main(){
  int a = 10 , b = 20 ;
  printf(" Value of 'a' before swap = %d \n", a );
  printf(" Value of 'b' before swap = %d \n", b );

  swap( & a , & b ) ;         //function call
  
  printf(" Value of 'a' after swap = %d \n", a );
  printf(" Value of 'b' after swap = %d \n", b );

return 0;
}

Hier zijn we Twee nummers verwisselen gebruik van wijzers.
Terwijl we de functie swap() aanroepen, sturen we de adressen van geheugenblokken (d.w.z. a, b) en om die adressen te nemen, nemen we integer-pointers als de argumenten in swap() (d.w.z. x, y).
In functie swap() wisselen we de waarden op de adressen om.

Uitvoer:

 Value of 'a' before swap = 10
 Value of 'b' before swap = 20
 Value of 'a' after swap = 20
 Value of 'b' after swap = 10
#include<stdio.h>

void func(int ** p1 )
{
    int b = 2;
    * p1 = & b;
}

int main()
{
    int a = 10;
    int * p = &a;
    printf("Before the function, value of the p : %d \n", * p) ;
    func(&p);    //function Call
    printf("After the function, new value of the p : %d \n", * p) ;

return 0;
}

Hier nemen we eerst een geheel getal 'a' en kennen er waarde 10 aan toe,
dan een integer pointer 'p' nemen en het adres van 'a' toewijzen aan 'p'.
Nu geven we in functie-aanroep func(), het adres van 'p' dat een aanwijzer is, om het adres van een aanwijzer te nemen, functie func() zou een integer-aanwijzer naar een aanwijzer als argument moeten hebben (d.w.z. p1 in func (p1) ).
In func() veranderen we de waarde van 10 naar 2.

Uitvoer:

Before the function, value of the p : 10
After the function, new value of the p : 2

Met dit artikel op OpenGenus moet je het volledige idee hebben van * vs ** pointer in C.