Forudsætning: Pointers Introduktion

Overvej følgende program:

C

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

I ovenstående program har vi en pointer ptr der peger på 0 ^th element i arrayet. På samme måde kan vi også erklære en pointer, der kan pege på hele arrayet i stedet for kun ét element i arrayet. Denne pointer er nyttig, når man taler om multidimensionelle arrays.

Syntaks:

data_type  (* var_name ) [size_of_array]; 

Her:

data_type er den type data, som arrayet indeholder. var_navn er navnet på pointervariablen. size_of_array er størrelsen af ​​det array, som markøren vil pege på.

Eksempel

int (*ptr)[10]; 

Her ptr er en pointer, der kan pege på en matrix med 10 heltal. Da subscript har højere forrang end indirektion, er det nødvendigt at omslutte indirektionsoperatoren og markørens navn inden for parentes. Her er typen af ​​ptr 'pointer til en matrix med 10 heltal.

Bemærk: Markøren, der peger på 0 ^th element af array og markøren, der peger på hele arrayet, er helt forskellige. 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;> }>

Produktion

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

Her, s er pointer til 0 ^th element i arrayet arr , mens ptr er en pointer, der peger på hele arrayet arr .

• Basistypen af s er int mens base type af ptr er 'en matrix af 5 heltal'.
• Vi ved, at pointer-aritmetikken udføres i forhold til grundstørrelsen, så hvis vi skriver ptr++, så er pointeren ptr vil blive flyttet fremad med 20 bytes.

Følgende figur viser pointeren p og ptr. Den mørkere pil angiver en pegepind til en matrix.

Ved dereference af et pointerudtryk får vi en værdi, der peges på af det pointerudtryk. Markøren til et array peger på et array, så når vi derefererer det, skulle vi få arrayet, og navnet på arrayet angiver basisadressen. Så hver gang en pointer til en matrix dereferences, får vi basisadressen for den matrix, som den peger på.

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

Produktion

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

Pointer til multidimensionelle arrays

1. Pointere og todimensionelle arrays

I et todimensionelt array kan vi få adgang til hvert element ved at bruge to subscripts, hvor det første subscript repræsenterer rækkenummeret og det andet subscript repræsenterer kolonnenummeret. Elementerne i 2-D-array kan også tilgås ved hjælp af pointer notation. Antag, at arr er et 2-D-array, vi kan få adgang til ethvert element arr[i][j] af arrayet ved hjælp af pointer-udtrykket *(*(arr + i) + j) . Nu vil vi se, hvordan dette udtryk kan udledes.
Lad os tage et todimensionelt array arr[3][4] :

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

Da hukommelsen i en computer er organiseret lineært, er det ikke muligt at gemme 2-D-arrayet i rækker og kolonner. Konceptet med rækker og kolonner er kun teoretisk, faktisk er et 2-D-array gemt i rækkefølge, dvs. rækker placeres ved siden af ​​hinanden. Følgende figur viser, hvordan ovenstående 2-D-array vil blive lagret i hukommelsen.

Hver række kan betragtes som et 1-D-array, så et todimensionelt array kan betragtes som en samling af en-dimensionelle arrays, der placeres efter hinanden. Med andre ord kan vi sige, at 2-D dimensionelle arrays, der er placeret efter hinanden. Så her arr er en matrix af 3 elementer, hvor hvert element er en 1-D matrix med 4 heltal.
Vi ved, at navnet på en matrix er en konstant pointer, der peger på 0 ^th 1-D array og indeholder adresse 5000. Siden arr er en 'peger til en matrix af 4 heltal', ifølge pointer-aritmetikken vil udtrykket arr + 1 repræsentere adressen 5016 og udtrykket arr + 2 vil repræsentere adressen 5032.
Så det kan vi sige arr peger på 0 ^th 1-D array, arr + 1 peger på 1 ^st 1-D array og arr + 2 peger på 2 ^nd 1-D array.

Generelt kan vi skrive:

 arr + i Points to ith element of arr ->Peger på det 1-D-array 

• Da arr + i peger på i ^th element af arr , ved dereferencing vil den få i ^th element af arr hvilket selvfølgelig er et 1-D array. Således udtrykket *(arr + i) giver os basisadressen på i ^th 1-D array.
• Vi ved, pointer-udtrykket *(arr + i) svarer til det sænkede udtryk arr[i] . Så *(arr + i) hvilket er det samme som arr[i] giver os basisadressen på i ^th 1-D array.
• For at få adgang til et individuelt element i vores 2-D-array bør vi være i stand til at få adgang til enhver j ^th element af i ^th 1-D array.
• Siden grundtypen af *(arr + i) er int og den indeholder adressen 0 ^th element af i ^th 1-D-array, kan vi få adresserne på efterfølgende elementer i i ^th 1-D-array ved at tilføje heltalsværdier til *(arr + i) .
• For eksempel *(arr + i) + 1 vil repræsentere adressen på 1 ^st element af 1 ^st element af i ^th 1-D array og *(arr+i)+2 vil repræsentere adressen på 2 ^nd element af i ^th 1-D array.
• På samme måde vil *(arr + i) + j repræsentere adressen på j ^th element af i ^th 1-D array. Ved at dereferere dette udtryk kan vi få j ^th element i i ^th 1-D array.

Pointere og tredimensionelle arrays

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

I et tredimensionelt array kan vi få adgang til hvert element ved at bruge tre subscripts. Lad os tage et 3-D-array - Vi kan betragte et tredimensionelt array som et array af 2-D-array, dvs. hvert element i et 3-D-array anses for at være et 2-D-array. 3D-arrayet arr kan betragtes som et array bestående af to elementer, hvor hvert element er et 2-D array. Navnet på arrayet arr er en pointer til 0 ^th 2-D array.

Altså pointerudtrykket *(*(*(arr + i ) + j ) + k) svarer til det sænkede udtryk arr[i][j][k].
Vi ved, at udtrykket *(arr + i) er ækvivalent med arr[i] og udtrykket *(*(arr + i) + j) er ækvivalent arr[i][j]. Så vi kan sige, at arr[i] repræsenterer basisadressen for i ^th 2-D-array og arr[i][j] repræsenterer basisadressen for j ^th 1-D array.

Eksempel

Nedenstående eksempel demonstrerer programmet til at udskrive elementer af 3D-array ved hjælp af pointere.

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

Produktion

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

Følgende figur viser, hvordan 3-D-arrayet, der bruges i ovenstående program, er lagret i hukommelsen.

Abonner på markør til et array

Formode arr er et 2D-array med 3 rækker og 4 kolonner og ptr er en pointer til en matrix med 4 heltal, og ptr indeholder basisadressen for array 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 pegepind til den første række 2-D matrix, dvs. matrix med 4 heltal, ptr + i vil pege på i ^th række. Om dereference ptr + i , får vi basisadressen på i ^th række. For at få adgang til adressen på j ^th element af i ^th række kan vi tilføje j til pointerudtrykket *(ptr + i) . Altså pointerudtrykket *(ptr + i) + j giver adressen på j ^th element af i ^th række og markørudtrykket *(*(ptr + i)+j) giver værdien af ​​j ^th element af i ^th række.
Vi ved, at pointerudtrykket *(*(ptr + i) + j) er ækvivalent med sænket udtryk ptr[i][j]. Så hvis vi har en pointer-variabel, der indeholder basisadressen for 2-D-array, så kan vi få adgang til elementerne i array ved at dobbeltabonnere den pointer-variabel.

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

Produktion

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