Zoals we weten, wordt een pointer gebruikt om het adres van een variabele in C op te slaan. Pointer verkort de toegangstijd van een variabele. In C kunnen we echter ook een pointer definiëren om het adres van een andere pointer op te slaan. Een dergelijke aanwijzer staat bekend als een dubbele aanwijzer (aanwijzer naar aanwijzer). De eerste pointer wordt gebruikt om het adres van een variabele op te slaan, terwijl de tweede pointer wordt gebruikt om het adres van de eerste pointer op te slaan. Laten we het begrijpen aan de hand van het onderstaande diagram.

De syntaxis voor het declareren van een dubbele pointer wordt hieronder gegeven.

 int **p; // pointer to a pointer which is pointing to an integer. 

Beschouw het volgende voorbeeld.

wat is een monitor

 #include void main () { int a = 10; int *p; int **pp; p = &a; // pointer p is pointing to the address of a pp = &p; // pointer pp is a double pointer pointing to the address of pointer p printf('address of a: %x
',p); // Address of a will be printed printf('address of p: %x
',pp); // Address of p will be printed printf('value stored at p: %d
',*p); // value stoted at the address contained by p i.e. 10 will be printed printf('value stored at pp: %d
',**pp); // value stored at the address contained by the pointer stoyred at pp } 

Uitvoer

 address of a: d26a8734 address of p: d26a8738 value stored at p: 10 value stored at pp: 10 

C dubbele aanwijzer voorbeeld

Laten we een voorbeeld bekijken waarbij de ene aanwijzer naar het adres van een andere aanwijzer wijst.

Zoals je in de bovenstaande afbeelding kunt zien, bevat p2 het adres van p (fff2) en bevat p het adres van de getalvariabele (fff4).

 #include int main(){ int number=50; int *p;//pointer to int int **p2;//pointer to pointer p=&number;//stores the address of number variable p2=&p; printf('Address of number variable is %x 
',&number); printf('Address of p variable is %x 
',p); printf('Value of *p variable is %d 
',*p); printf('Address of p2 variable is %x 
',p2); printf('Value of **p2 variable is %d 
',*p); return 0; } 

Uitvoer

 Address of number variable is fff4 Address of p variable is fff4 Value of *p variable is 50 Address of p2 variable is fff2 Value of **p variable is 50 

V. Wat zal de uitvoer zijn van het volgende programma?

 #include void main () { int a[10] = {100, 206, 300, 409, 509, 601}; //Line 1 int *p[] = {a, a+1, a+2, a+3, a+4, a+5}; //Line 2 int **pp = p; //Line 3 pp++; // Line 4 printf('%d %d %d
',pp-p,*pp - a,**pp); // Line 5 *pp++; // Line 6 printf('%d %d %d
',pp-p,*pp - a,**pp); // Line 7 ++*pp; // Line 8 printf('%d %d %d
',pp-p,*pp - a,**pp); // Line 9 ++**pp; // Line 10 printf('%d %d %d
',pp-p,*pp - a,**pp); // Line 11 } 

Uitleg

In de bovenstaande vraag wordt de pointer-rekenkunde gebruikt met de dubbele pointer. Er wordt een array van 6 elementen gedefinieerd die wordt aangegeven door een array van aanwijzer p. De pointer-array p wordt aangewezen door een dubbele pointer pp. De bovenstaande afbeelding geeft u echter een kort idee van hoe het geheugen wordt toegewezen aan de array a en de pointer-array p. De elementen van p zijn de verwijzingen die naar elk element van de array a wijzen. Omdat we weten dat de arraynaam het basisadres van de array bevat, zal deze als pointer werken en kan de waarde worden doorlopen met behulp van *(a), *(a+1), enz. Zoals weergegeven in de afbeelding , a[0] kan op de volgende manieren worden benaderd.

converteer tekenreeks naar json-object

• a[0]: dit is de eenvoudigste manier om toegang te krijgen tot het eerste element van de array
• *(a): aangezien we het adres van het eerste element van de array opslaan, kunnen we toegang krijgen tot de waarde ervan door er een indirecte aanwijzer op te gebruiken.
• *p[0]: als toegang moet worden verkregen tot a[0] door er een pointer p naartoe te gebruiken, dan kunnen we de indirectie-operator (*) gebruiken op het eerste element van de pointer-array p, d.w.z. *p[0].
• **(pp): aangezien pp het basisadres van de pointer-array opslaat, zal *pp de waarde geven van het eerste element van de pointer-array dat het adres is van het eerste element van de integer-array. **p geeft de werkelijke waarde van het eerste element van de integer-array.

Als we naar het programma komen, declareren regel 1 en 2 de integer- en pointer-array relatief. Regel 3 initialiseert de dubbele pointer naar de pointer-array p. Zoals weergegeven in de afbeelding, als het adres van de array begint bij 200 en de grootte van het gehele getal 2 is, zal de pointerarray de waarden 200, 202, 204, 206, 208, 210 bevatten. Laten we bedenken dat de basisadres van de pointerarray is 300; de dubbele pointer pp bevat het adres van de pointer-array, d.w.z. 300. Regelnummer 4 verhoogt de waarde van pp met 1, d.w.z. pp zal nu naar adres 302 wijzen.

Regelnummer 5 bevat een uitdrukking die drie waarden afdrukt, namelijk pp - p, *pp - a, **pp. Laten we ze stuk voor stuk berekenen.

• pp = 302, p = 300 => pp-p = (302-300)/2 => pp-p = 1, d.w.z. er wordt 1 afgedrukt.
• pp = 302, *pp = 202, a = 200 => *pp - a = 202 - 200 = 2/2 = 1, d.w.z. er wordt 1 afgedrukt.
• pp = 302, *pp = 202, *(*pp) = 206, d.w.z. er wordt 206 afgedrukt.

Daarom wordt als resultaat van regel 5 de uitvoer 1, 1, 206 op de console afgedrukt. Op regel 6 wordt *pp++ geschreven. Hier moeten we opmerken dat twee unaire operatoren * en ++ dezelfde prioriteit zullen hebben. Daarom zal het, volgens de regel van associativiteit, van rechts naar links worden geëvalueerd. Daarom kan de uitdrukking *pp++ herschreven worden als (*(pp++)). Omdat pp = 302, wat nu 304 wordt. *pp geeft 204.

Op regel 7 wordt opnieuw de uitdrukking geschreven die drie waarden afdrukt, namelijk pp-p, *pp-a, *pp. Laten we ze allemaal berekenen.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.w.z. er wordt 2 afgedrukt.
• pp = 304, *pp = 204, a = 200 => *pp-a = (204 - 200)/2 = 2, d.w.z. er wordt 2 afgedrukt.
• pp = 304, *pp = 204, *(*pp) = 300, d.w.z. er worden 300 afgedrukt.

Daarom wordt als resultaat van regel 7 de uitvoer 2, 2, 300 op de console afgedrukt. Op regel 8 wordt +**pp geschreven. Volgens de regel van associativiteit kan dit worden herschreven als (++(*(pp))). Aangezien pp = 304, *pp = 204, is de waarde van *pp = *(p[2]) = 206, die nu naar a[3] wijst.

laat gebruikers mysql zien

Op regel 9 wordt opnieuw de uitdrukking geschreven die drie waarden afdrukt, namelijk pp-p, *pp-a, *pp. Laten we ze allemaal berekenen.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.w.z. er wordt 2 afgedrukt.
• pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, d.w.z. er wordt 3 afgedrukt.
• pp = 304, *pp = 206, *(*pp) = 409, d.w.z. 409 wordt afgedrukt.

Daarom wordt als resultaat van regel 9 de uitvoer 2, 3, 409 op de console afgedrukt. Op regel 10 wordt ++**pp geschreven. volgens de regel van associativiteit kan dit worden herschreven als (++(*(*(pp)))). pp = 304, *pp = 206, **pp = 409, ++**pp => *pp = *pp + 1 = 410. Met andere woorden, a[3] = 410.

Op regel 11 wordt opnieuw de uitdrukking geschreven die drie waarden afdrukt, namelijk pp-p, *pp-a, *pp. Laten we ze allemaal berekenen.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.w.z. er wordt 2 afgedrukt.
• pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, d.w.z. er wordt 3 afgedrukt.
• Op regel 8, **pp = 410.

Daarom wordt als resultaat van regel 9 de uitvoer 2, 3, 410 op de console afgedrukt.

Uiteindelijk wordt de uitvoer van het volledige programma gegeven als:

Uitvoer

 1 1 206 2 2 300 2 3 409 2 3 410