Som vi vet används en pekare för att lagra adressen till en variabel i C. Pekaren minskar åtkomsttiden för en variabel. Men i C kan vi också definiera en pekare för att lagra adressen till en annan pekare. En sådan pekare är känd som en dubbelpekare (pekare till pekare). Den första pekaren används för att lagra adressen till en variabel medan den andra pekaren används för att lagra adressen till den första pekaren. Låt oss förstå det med diagrammet nedan.
Syntaxen för att deklarera en dubbelpekare ges nedan.
int **p; // pointer to a pointer which is pointing to an integer.
Betrakta följande exempel.
python konvertera byte till sträng
#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 dubbelpekare exempel
Låt oss se ett exempel där en pekare pekar på adressen till en annan pekare.
Som du kan se i figuren ovan innehåller p2 adressen till p (fff2), och p innehåller adressen till nummervariabeln (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
F. Vad blir resultatet av följande 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 } Förklaring
I ovanstående fråga används pekarens aritmetik med dubbelpekaren. En array med 6 element definieras som pekas av en array av pekaren p. Pekarmatrisen p pekas av en dubbelpekare pp. Bilden ovan ger dig dock en kort uppfattning om hur minnet allokeras till matrisen a och pekarmatrisen p. Elementen i p är pekarna som pekar på varje element i arrayen a. Eftersom vi vet att arraynamnet innehåller arrayens basadress, kommer det att fungera som en pekare och kan värdet passeras genom att använda *(a), *(a+1), etc. Som visas i bilden , a[0] kan nås på följande sätt.
java sömn
- a[0]: det är det enklaste sättet att komma åt det första elementet i arrayen
- *(a): eftersom en lagrar adressen till det första elementet i arrayen, kan vi komma åt dess värde genom att använda inriktningspekaren på den.
- *p[0]: om a[0] ska nås genom att använda en pekare p till den, så kan vi använda indirektionsoperator (*) på det första elementet i pekarmatrisen p, dvs *p[0].
- **(pp): eftersom pp lagrar basadressen för pekarmatrisen, kommer *pp att ge värdet för det första elementet i pekarmatrisen som är adressen till det första elementet i heltalsmatrisen. **p kommer att ge det faktiska värdet för det första elementet i heltalsmatrisen.
När du kommer till programmet, deklarerar rad 1 och 2 heltals- och pekarmatrisen relativt. Rad 3 initierar dubbelpekaren till pekarmatrisen p. Som visas i bilden, om adressen till matrisen börjar från 200 och storleken på heltal är 2, kommer pekarmatrisen att innehålla värdena som 200, 202, 204, 206, 208, 210. Låt oss tänka på att basadress för pekarmatrisen är 300; dubbelpekaren pp innehåller adressen till pekarmatrisen, dvs 300. Rad nummer 4 ökar värdet på pp med 1, dvs pp kommer nu att peka på adress 302.
Rad nummer 5 innehåller ett uttryck som skriver ut tre värden, dvs pp - p, *pp - a, **pp. Låt oss beräkna dem var och en av dem.
- pp = 302, p = 300 => pp-p = (302-300)/2 => pp-p = 1, d.v.s. 1 kommer att skrivas ut.
- pp = 302, *pp = 202, a = 200 => *pp - a = 202 - 200 = 2/2 = 1, d.v.s. 1 kommer att skrivas ut.
- pp = 302, *pp = 202, *(*pp) = 206, d.v.s. 206 kommer att skrivas ut.
Som ett resultat av rad 5 kommer därför utdata 1, 1, 206 att skrivas ut på konsolen. På rad 6 skrivs *pp++. Här måste vi notera att två unära operatorer * och ++ kommer att ha samma prioritet. Därför kommer den att utvärderas från höger till vänster enligt associativitetsregeln. Därför kan uttrycket *pp++ skrivas om till (*(pp++)). Eftersom pp = 302 som nu blir 304. *pp ger 204.
På rad 7 skrivs återigen uttrycket som skriver ut tre värden, dvs pp-p, *pp-a, *pp. Låt oss beräkna var och en av dem.
- pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.v.s. 2 kommer att skrivas ut.
- pp = 304, *pp = 204, a = 200 => *pp-a = (204 - 200)/2 = 2, d.v.s. 2 kommer att skrivas ut.
- pp = 304, *pp = 204, *(*pp) = 300, d.v.s. 300 kommer att skrivas ut.
Därför, som ett resultat av rad 7, kommer utdata 2, 2, 300 att skrivas ut på konsolen. På rad 8 skrivs ++*pp. Enligt associativitetsregeln kan detta skrivas om som, (++(*(pp))). Eftersom pp = 304, *pp = 204, värdet av *pp = *(p[2]) = 206, vilket nu pekar på a[3].
shilpa shetty ålder
På rad 9 skrivs återigen uttrycket som skriver ut tre värden, dvs pp-p, *pp-a, *pp. Låt oss beräkna var och en av dem.
- pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.v.s. 2 kommer att skrivas ut.
- pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, d.v.s. 3 kommer att skrivas ut.
- pp = 304, *pp = 206, *(*pp) = 409, d.v.s. 409 kommer att skrivas ut.
Därför, som ett resultat av rad 9, kommer utdata 2, 3, 409 att skrivas ut på konsolen. På rad 10 skrivs ++**pp. enligt associativitetsregeln kan detta skrivas om som, (++(*(*(pp)))). pp = 304, *pp = 206, **pp = 409, ++**pp => *pp = *pp + 1 = 410. Med andra ord, a[3] = 410.
På rad 11 skrivs återigen uttrycket som skriver ut tre värden, dvs pp-p, *pp-a, *pp. Låt oss beräkna var och en av dem.
- pp = 304, p = 300 => pp - p = (304 - 300)/2 => pp-p = 2, d.v.s. 2 kommer att skrivas ut.
- pp = 304, *pp = 206, a = 200 => *pp-a = (206 - 200)/2 = 3, d.v.s. 3 kommer att skrivas ut.
- På rad 8, **pp = 410.
Som ett resultat av rad 9 kommer därför utdata 2, 3, 410 att skrivas ut på konsolen.
Slutligen kommer resultatet av hela programmet att ges som:
Produktion
1 1 206 2 2 300 2 3 409 2 3 410