Som vi ved, bruges en pointer til at gemme adressen på en variabel i C. Pointer reducerer adgangstiden for en variabel. I C kan vi dog også definere en pointer til at gemme adressen på en anden pointer. En sådan pointer er kendt som en dobbelt pointer (pointer to pointer). Den første pointer bruges til at gemme adressen på en variabel, mens den anden pointer bruges til at gemme adressen på den første pointer. Lad os forstå det ved hjælp af diagrammet nedenfor.

Syntaksen for at erklære en dobbelt pointer er angivet nedenfor.

array sortere java

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

Overvej følgende eksempel.

 #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 } 

Produktion

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

C dobbelt pointer eksempel

Lad os se et eksempel, hvor en pointer peger på adressen på en anden pointer.

Som du kan se i ovenstående figur, indeholder p2 adressen på p (fff2), og p indeholder adressen på talvariablen (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; } 

Produktion

 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 

Q. Hvad bliver resultatet af følgende program?

 #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 } 

Forklaring

I ovenstående spørgsmål bruges pointer-aritmetikken med den dobbelte pointer. Et array med 6 elementer er defineret, som peges af en array af pointer p. Pointer-arrayet p peges af en dobbelt pointer pp. Ovenstående billede giver dig dog en kort idé om, hvordan hukommelsen allokeres til array a og pointer-array p. Elementerne i p er de pointere, der peger på hvert element i arrayet a. Da vi ved, at arraynavnet indeholder basisadressen for arrayet, vil det derfor fungere som en pointer og kan værdien krydses ved at bruge *(a), *(a+1), osv. Som vist på billedet , a[0] kan tilgås på følgende måder.

• a[0]: det er den enkleste måde at få adgang til det første element i arrayet
• *(a): da en gemmer adressen på det første element i arrayet, kan vi få adgang til dets værdi ved at bruge en indirektionsmarkør på den.
• *p[0]: hvis a[0] skal tilgås ved at bruge en pointer p til den, så kan vi bruge indirektionsoperator (*) på det første element af pointer-arrayet p, dvs. *p[0].
• **(pp): da pp gemmer basisadressen for pointer-arrayet, vil *pp give værdien af ​​det første element i pointer-arrayet, som er adressen på det første element i heltalsarrayet. **p vil give den faktiske værdi af det første element i heltalsarrayet.

Når man kommer til programmet, erklærer linje 1 og 2 heltals- og pointer-arrayet relativt. Linje 3 initialiserer dobbeltmarkøren til pointer-arrayet p. Som vist på billedet, hvis adressen på arrayet starter fra 200 og størrelsen af ​​hele tallet er 2, vil pointer-arrayet indeholde værdierne som 200, 202, 204, 206, 208, 210. Lad os overveje, at basisadressen for pointer-arrayet er 300; den dobbelte pointer pp indeholder adressen på pointer array, dvs. 300. Linje nummer 4 øger værdien af ​​pp med 1, dvs. pp vil nu pege på adresse 302.

Linje nummer 5 indeholder et udtryk, som udskriver tre værdier, dvs. pp - p, *pp - a, **pp. Lad os beregne dem hver enkelt af dem.

hvor mange 0 i en milliard

• pp = 302, p = 300 => pp-p = (302-300)/2 => pp-p = 1, dvs. 1 vil blive udskrevet.
• pp = 302, *pp = 202, a = 200 => *pp - a = 202 - 200 = 2/2 = 1, dvs. 1 vil blive udskrevet.
• pp = 302, *pp = 202, *(*pp) = 206, dvs. 206 vil blive udskrevet.

Som et resultat af linje 5 vil output 1, 1, 206 derfor blive udskrevet på konsollen. På linje 6 skrives *pp++. Her skal vi bemærke, at to unære operatorer * og ++ vil have samme forrang. Derfor vil den ved reglen om associativitet blive evalueret fra højre mod venstre. Derfor kan udtrykket *pp++ omskrives som (*(pp++)). Da pp = 302, som nu bliver til 304. *pp vil give 204.

På linje 7 er der igen skrevet udtrykket, som udskriver tre værdier, dvs. pp-p, *pp-a, *pp. Lad os beregne hver enkelt af dem.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, dvs. 2 vil blive udskrevet.
• pp = 304, *pp = 204, a = 200 => *pp-a = (204 - 200)/2 = 2, dvs. 2 vil blive udskrevet.
• pp = 304, *pp = 204, *(*pp) = 300, dvs. 300 vil blive udskrevet.

Som et resultat af linje 7 vil output 2, 2, 300 derfor blive udskrevet på konsollen. På linje 8 skrives ++*pp. I henhold til associativitetsreglen kan dette omskrives som, (++(*(pp))). Da pp = 304, *pp = 204, værdien af ​​*pp = *(p[2]) = 206, hvilket nu vil pege på a[3].

tilføjelse til array java

På linje 9 skrives igen udtrykket, som udskriver tre værdier, dvs. pp-p, *pp-a, *pp. Lad os beregne hver enkelt af dem.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, dvs. 2 vil blive udskrevet.
• pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, dvs. 3 vil blive udskrevet.
• pp = 304, *pp = 206, *(*pp) = 409, dvs. 409 vil blive udskrevet.

Som et resultat af linje 9 vil output 2, 3, 409 derfor blive udskrevet på konsollen. På linje 10 skrives ++**pp. i henhold til associativitetsreglen kan dette omskrives som, (++(*(*(pp)))). pp = 304, *pp = 206, **pp = 409, ++**pp => *pp = *pp + 1 = 410. Med andre ord, a[3] = 410.

På linje 11 skrives igen udtrykket, som udskriver tre værdier, dvs. pp-p, *pp-a, *pp. Lad os beregne hver enkelt af dem.

• pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, dvs. 2 vil blive udskrevet.
• pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, dvs. 3 vil blive udskrevet.
• På linje 8, **pp = 410.

Som et resultat af linje 9 vil output 2, 3, 410 derfor blive udskrevet på konsollen.

java-streng af array

Til sidst vil outputtet af det komplette program blive givet som:

Produktion

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