Forutsetning: Pekere Introduksjon

Tenk på følgende program:

C

#include> int> main()> {> > int> arr[5] = { 1, 2, 3, 4, 5 };> > int> *ptr = arr;> > printf> (> '%p '> , ptr);> > return> 0;> }>

I programmet ovenfor har vi en peker ptr som peker på 0 ^th element i matrisen. På samme måte kan vi også deklarere en peker som kan peke til hele matrisen i stedet for bare ett element i matrisen. Denne pekeren er nyttig når du snakker om flerdimensjonale matriser.

Syntaks:

data_type  (* var_name ) [size_of_array]; 

Her:

data_type er typen data som matrisen inneholder. var_navn er navnet på pekervariabelen. size_of_array er størrelsen på matrisen som pekeren skal peke til.

Eksempel

int (*ptr)[10]; 

Her ptr er en peker som kan peke til en matrise med 10 heltall. Siden subscript har høyere prioritet enn indirektion, er det nødvendig å omslutte indirektionsoperatøren og pekernavnet innenfor parentes. Her er typen ptr 'peker til en matrise med 10 heltall.

Merk: Pekeren som peker til 0 ^th element av matrise og pekeren som peker til hele matrisen er helt forskjellige. Følgende program viser dette:

C

// C program to understand difference between> // pointer to an integer and pointer to an> // array of integers.> #include> int> main()> {> > // Pointer to an integer> > int> *p;> > > // Pointer to an array of 5 integers> > int> (*ptr)[5];> > int> arr[5];> > > // Points to 0th element of the arr.> > p = arr;> > > // Points to the whole array arr.> > ptr = &arr;> > > printf> (> 'p = %p, ptr = %p '> , p, ptr);> > > p++;> > ptr++;> > > printf> (> 'p = %p, ptr = %p '> , p, ptr);> > > return> 0;> }>

Produksjon

p = 0x7fff6463e890, ptr = 0x7fff6463e890 p = 0x7fff6463e894, ptr = 0x7fff6463e8a4 

Her, s er pekeren til 0 ^th element i matrisen arr , samtidig som ptr er en peker som peker til hele matrisen arr .

• Grunntypen av s er int mens basetype av ptr er 'en matrise med 5 heltall'.
• Vi vet at peker-aritmetikken utføres i forhold til grunnstørrelsen, så hvis vi skriver ptr++, så er pekeren ptr vil bli forskjøvet fremover med 20 byte.

Følgende figur viser pekeren p og ptr. Den mørkere pilen angir en peker til en matrise.

Ved frareferanse til et pekeruttrykk får vi en verdi pekt på av det pekeruttrykket. Pekeren til en matrise peker på en matrise, så ved frareferanse til den bør vi få matrisen, og navnet på matrisen angir baseadressen. Så hver gang en peker til en matrise derefereres, får vi baseadressen til matrisen den peker til.

C

// C program to illustrate sizes of> // pointer of array> #include> int> main()> {> > int> arr[] = { 3, 5, 6, 7, 9 };> > int> *p = arr;> > int> (*ptr)[5] = &arr;> > > printf> (> 'p = %p, ptr = %p '> , p, ptr);> > printf> (> '*p = %d, *ptr = %p '> , *p, *ptr);> > > printf> (> 'sizeof(p) = %lu, sizeof(*p) = %lu '> ,> > sizeof> (p),> sizeof> (*p));> > printf> (> 'sizeof(ptr) = %lu, sizeof(*ptr) = %lu '> ,> > sizeof> (ptr),> sizeof> (*ptr));> > return> 0;> }>

Produksjon

p = 0x7fff55adbff0, ptr = 0x7fff55adbff0 *p = 3, *ptr = 0x7fff55adbff0 sizeof(p) = 8, sizeof(*p) = 4 sizeof(ptr) = 8, sizeof(*ptr) = 20 

Peker til flerdimensjonale matriser

1. Pekere og todimensjonale matriser

I en todimensjonal array kan vi få tilgang til hvert element ved å bruke to subscripts, der det første subscriptet representerer radnummeret og det andre subscriptet representerer kolonnenummeret. Elementene i 2-D-array kan også nås ved hjelp av pekernotasjon. Anta at arr er en 2D-matrise, vi kan få tilgang til et hvilket som helst element arr[i][j] av matrisen ved å bruke pekeruttrykket *(*(arr + i) + j) . Nå skal vi se hvordan dette uttrykket kan utledes.
La oss ta en todimensjonal matrise arr[3][4] :

int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} }; 

Siden minnet i en datamaskin er organisert lineært, er det ikke mulig å lagre 2-D-matrisen i rader og kolonner. Konseptet med rader og kolonner er bare teoretisk, faktisk er en 2-D-array lagret i rekkefølge, dvs. rader plasseres ved siden av hverandre. Følgende figur viser hvordan 2D-arrayen ovenfor vil bli lagret i minnet.

Hver rad kan betraktes som en 1-D-matrise, så en todimensjonal matrise kan betraktes som en samling endimensjonale matriser som plasseres etter hverandre. Med andre ord kan vi si at 2-D dimensjonale arrays som er plassert etter hverandre. Så her arr er en matrise med 3 elementer hvor hvert element er en 1-D matrise med 4 heltall.
Vi vet at navnet på en matrise er en konstant peker som peker på 0 ^th 1-D array og inneholder adresse 5000. Siden arr er en 'peker til en matrise med 4 heltall', i henhold til pekeraritmetikk vil uttrykket arr + 1 representere adressen 5016 og uttrykket arr + 2 vil representere adressen 5032.
Så det kan vi si arr peker på 0 ^th 1-D array, arr + 1 peker på 1 ^st 1-D array og arr + 2 peker på 2 ^nd 1-D-array.

Generelt kan vi skrive:

 arr + i Points to ith element of arr ->Peker på den 1-D-matrisen 

• Siden arr + i peker på i ^th element av arr , ved referanse vil den få i ^th element av arr som selvfølgelig er en 1-D array. Altså uttrykket *(arr + i) gir oss basisadressen til i ^th 1-D-array.
• Vi vet, pekeruttrykket *(arr + i) er ekvivalent med subscript-uttrykket arr[i] . Så *(arr + i) som er det samme som arr[i] gir oss basisadressen til i ^th 1-D-array.
• For å få tilgang til et individuelt element i 2-D-arrayet vårt, bør vi kunne få tilgang til enhver j ^th element av i ^th 1-D-array.
• Siden basen type *(arr + i) er int og den inneholder adressen til 0 ^th element av i ^th 1-D-array, kan vi få adressene til påfølgende elementer i i ^th 1-D-matrise ved å legge til heltallsverdier til *(arr + i) .
• For eksempel *(arr + i) + 1 vil representere adressen til 1 ^st element av 1 ^st element av i ^th 1-D array og *(arr+i)+2 vil representere adressen til 2 ^nd element av i ^th 1-D-array.
• På samme måte vil *(arr + i) + j representere adressen til j ^th element av i ^th 1-D-array. Ved å referere dette uttrykket kan vi få j ^th element i i ^th 1-D-array.

Pekere og tredimensjonale matriser

int arr[2][3][2] = { {{5, 10}, {6, 11}, {7, 12}}, {{20, 30}, {21, 31}, {22, 32}} }; 

I en tredimensjonal matrise kan vi få tilgang til hvert element ved å bruke tre abonnenter. La oss ta en 3-D-matrise - Vi kan betrakte en tredimensjonal matrise som en matrise med 2-D-matrise, dvs. hvert element i en 3-D-matrise anses å være en 2-D-matrise. 3D-matrisen arr kan betraktes som en matrise bestående av to elementer hvor hvert element er en 2D-matrise. Navnet på matrisen arr er en peker til 0 ^th 2D-array.

Altså pekeruttrykket *(*(*(arr + i ) + j ) + k) tilsvarer det nedskrevne uttrykket arr[i][j][k].
Vi vet at uttrykket *(arr + i) er ekvivalent med arr[i] og uttrykket *(*(arr + i) + j) er ekvivalent arr[i][j]. Så vi kan si at arr[i] representerer basisadressen til i ^th 2-D array og arr[i][j] representerer basisadressen til j ^th 1-D-array.

Eksempel

Eksemplet nedenfor viser programmet for å skrive ut elementer av 3D-array ved hjelp av pekere.

C

// C program to print the elements of 3-D> // array using pointer notation> #include> int> main()> {> > int> arr[2][3][2] = {> > {> > {5, 10},> > {6, 11},> > {7, 12},> > },> > {> > {20, 30},> > {21, 31},> > {22, 32},> > }> > };> > int> i, j, k;> > for> (i = 0; i <2; i++)> > {> > for> (j = 0; j <3; j++)> > {> > for> (k = 0; k <2; k++)> > printf> (> '%d '> , *(*(*(arr + i) + j) +k));> > printf> (> ' '> );> > }> > }> > return> 0;> }>

Produksjon

5 10 6 11 7 12 20 30 21 31 22 32 

Følgende figur viser hvordan 3-D-matrisen som brukes i programmet ovenfor, er lagret i minnet.

Registrere peker til en matrise

Anta arr er en 2D-matrise med 3 rader og 4 kolonner og ptr er en peker til en matrise med 4 heltall, og ptr inneholder basisadressen til matrisen arr .

int arr[3][4] = {{10, 11, 12, 13}, {20, 21, 22, 23}, {30, 31, 32, 33}}; int (*ptr)[4]; ptr = arr; 

Siden ptr er en peker til den første radens 2D-matrise, dvs. en matrise med 4 heltall, ptr + i vil peke på i ^th rad. Om referanse ptr + i , får vi baseadressen til i ^th rad. For å få tilgang til adressen til j ^th element av i ^th rad kan vi legge til j til pekeruttrykket *(ptr + i) . Altså pekeruttrykket *(ptr + i) + j gir adressen til j ^th element av i ^th rad og pekeruttrykket *(*(ptr + i)+j) gir verdien av j ^th element av i ^th rad.
Vi vet at pekeruttrykket *(*(ptr + i) + j) er ekvivalent med subskriptuttrykket ptr[i][j]. Så hvis vi har en pekervariabel som inneholder basisadressen til 2-D-matrisen, kan vi få tilgang til elementene i matrisen ved å dobbeltabonnere den pekervariabelen.

Eksempel

C

// C program to print elements of a 2-D array> // by scripting a pointer to an array> #include> int> main()> {> > int> arr[3][4] = {> > {10, 11, 12, 13},> > {20, 21, 22, 23},> > {30, 31, 32, 33}> > };> > int> (*ptr)[4];> > ptr = arr;> > printf> (> '%p %p %p '> , ptr, ptr + 1, ptr + 2);> > printf> (> '%p %p %p '> , *ptr, *(ptr + 1), *(ptr + 2));> > printf> (> '%d %d %d '> , **ptr, *(*(ptr + 1) + 2), *(*(ptr + 2) + 3));> > printf> (> '%d %d %d '> , ptr[0][0], ptr[1][2], ptr[2][3]);> > return> 0;> }>

Produksjon

0x7ffc9556b790 0x7ffc9556b7a0 0x7ffc9556b7b0 0x7ffc9556b790 0x7ffc9556b7a0 0x7ffc9556b7b0 10 22 33 10 22 33