Priekšnosacījums: Norādes Ievads

Apsveriet šādu programmu:

C

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

Iepriekš minētajā programmā mums ir rādītājs ptr kas norāda uz 0 ^th masīva elements. Līdzīgi mēs varam arī deklarēt rādītāju, kas var norādīt uz visu masīvu, nevis tikai uz vienu masīva elementu. Šis rādītājs ir noderīgs, runājot par daudzdimensiju masīviem.

Sintakse:

data_type  (* var_name ) [size_of_array]; 

Šeit:

datu_veids ir datu veids, kas glabājas masīvā. var_nosaukums ir rādītāja mainīgā nosaukums. masīva_izmērs ir masīva lielums, uz kuru norādīs rādītājs.

Piemērs

int (*ptr)[10]; 

Šeit ptr ir rādītājs, kas var norādīt uz 10 veselu skaitļu masīvu. Tā kā apakšindeksam ir augstāka prioritāte nekā netiešajam indeksam, iekavās ir jāiekļauj netiešā virziena operators un rādītāja nosaukums. Šeit ptr veids ir “rādītājs uz 10 veselu skaitļu masīvu”.

Piezīme: rādītājs, kas norāda uz 0 ^th masīva elements un rādītājs, kas norāda uz visu masīvu, ir pilnīgi atšķirīgi. To parāda šī programma:

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

Izvade

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

Šeit, lpp ir rādītājs uz 0 ^th masīva elements arr , kamēr ptr ir rādītājs, kas norāda uz visu masīvu arr .

• Pamata veids lpp ir int, kamēr bāzes tips ptr ir “5 veselu skaitļu masīvs”.
• Mēs zinām, ka rādītāja aritmētika tiek veikta attiecībā pret bāzes izmēru, tāpēc, ja mēs rakstām ptr++, tad rādītājs ptr tiks pārvietots uz priekšu par 20 baitiem.

Nākamajā attēlā parādīts rādītājs p un ptr. Tumšāka bultiņa apzīmē rādītāju uz masīvu.

Atsaucot norādes izteiksmi, mēs iegūstam vērtību, uz kuru norāda šī rādītāja izteiksme. Rādītājs uz masīvu norāda uz masīvu, tāpēc, atceļot uz to atsauci, mums vajadzētu iegūt masīvu, un masīva nosaukums apzīmē bāzes adresi. Tātad ikreiz, kad no rādītāja uz masīvu tiek noņemta atsauce, mēs iegūstam tā masīva bāzes adresi, uz kuru tas norāda.

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

Izvade

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

Rādītājs uz daudzdimensiju masīviem

1. Rādītāji un divdimensiju masīvi

Divdimensiju masīvā mēs varam piekļūt katram elementam, izmantojot divus apakšindeksus, kur pirmais apakšindekss apzīmē rindas numuru, bet otrais apakšindekss apzīmē kolonnas numuru. 2-D masīva elementiem var piekļūt arī ar rādītāja apzīmējumu palīdzību. Pieņemsim, ka arr ir 2-D masīvs, mēs varam piekļūt jebkuram elementam arr[i][j] masīva, izmantojot rādītāja izteiksmi **(*(arr + i) + j) . Tagad mēs redzēsim, kā šo izteiksmi var iegūt.
Ņemsim divdimensiju masīvu arr[3][4] :

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

Tā kā atmiņa datorā ir sakārtota lineāri, 2-D masīvu nav iespējams saglabāt rindās un kolonnās. Rindu un kolonnu jēdziens ir tikai teorētisks, faktiski 2-D masīvs tiek saglabāts rindu galvenajā secībā, t.i. rindas ir novietotas blakus. Nākamajā attēlā parādīts, kā iepriekš minētais 2-D masīvs tiks saglabāts atmiņā.

Katru rindu var uzskatīt par 1-D masīvu, tāpēc divdimensiju masīvu var uzskatīt par viendimensiju masīvu kopumu, kas ir izvietoti viens pēc otra. Citiem vārdiem sakot, mēs varam teikt, ka 2-D dimensiju masīvi, kas tiek novietoti viens pēc otra. Tātad šeit arr ir 3 elementu masīvs, kur katrs elements ir 4 veselu skaitļu 1-D masīvs.
Mēs zinām, ka masīva nosaukums ir nemainīgs rādītājs, kas norāda uz 0 ^th 1-D masīvs un satur adresi 5000. Kopš arr ir “rādītājs uz 4 veselu skaitļu masīvu”, saskaņā ar rādītāja aritmētiku izteiksme arr + 1 apzīmēs adresi 5016 un izteiksme arr + 2 apzīmēs adresi 5032.
Tātad mēs varam tā teikt arr norāda uz 0 ^th 1-D masīvs, arr + 1 norāda uz 1 ^st 1-D masīvs un arr + 2 norāda uz 2 ^nd 1-D masīvs.

Kopumā mēs varam rakstīt:

 arr + i Points to ith element of arr ->Norāda uz i-to 1-D masīvu 

• Tā kā arr + i norāda uz i ^th elements arr , noņemot atsauci, tas saņems i ^th elements arr kas, protams, ir 1-D masīvs. Tādējādi izteiksme *(arr + i) dod mums i bāzes adresi ^th 1-D masīvs.
• Mēs zinām, rādītāja izteiksme *(arr + i) ir līdzvērtīgs apakšindeksa izteiksmei arr[i] . Tātad *(arr + i) kas ir tāds pats kā arr[i] dod mums i bāzes adresi ^th 1-D masīvs.
• Lai piekļūtu atsevišķam mūsu 2-D masīva elementam, mums vajadzētu būt iespējai piekļūt jebkuram j ^th i elements ^th 1-D masīvs.
• Kopš bāzes tipa *(arr + i) ir starpt un tajā ir adrese 0 ^th i elements ^th 1-D masīvs, mēs varam iegūt turpmāko elementu adreses i ^th 1-D masīvs, pievienojot veselu skaitļu vērtības *(arr + i) .
• Piemēram *(arr + i) + 1 pārstāvēs 1. adresi ^st 1. elements ^st i elements ^th 1-D masīvs un *(arr+i)+2 pārstāvēs 2. adresi ^nd i elements ^th 1-D masīvs.
• Līdzīgi *(arr + i) + j apzīmēs j adresi ^th i elements ^th 1-D masīvs. Atsaucot šo izteiksmi, mēs varam iegūt j ^th i elements ^th 1-D masīvs.

Rādītāji un trīsdimensiju masīvi

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

Trīsdimensiju masīvā mēs varam piekļūt katram elementam, izmantojot trīs apakšindeksus. Ņemsim 3-D masīvu. Trīsdimensiju masīvu var uzskatīt par 2-D masīvu masīvu, t.i., katrs 3-D masīva elements tiek uzskatīts par 2-D masīvu. 3-D masīvs arr var uzskatīt par masīvu, kas sastāv no diviem elementiem, kur katrs elements ir 2-D masīvs. Masīva nosaukums arr ir rādītājs uz 0 ^th 2-D masīvs.

Tādējādi rādītāja izteiksme *(*(*(arr + i ) + j ) + k) ir ekvivalents apakšindeksa izteiksmei arr[i][j][k].
Mēs zinām, ka izteiksme *(arr + i) ir ekvivalenta arr[i], un izteiksme *(*(arr + i) + j) ir ekvivalenta arr[i][j]. Tātad mēs varam teikt, ka arr[i] apzīmē i bāzes adresi ^th 2-D masīvs un arr[i][j] apzīmē j bāzes adresi ^th 1-D masīvs.

Piemērs

Tālāk esošajā piemērā ir parādīta programma 3D masīva elementu drukāšanai, izmantojot norādes.

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

Izvade

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

Nākamajā attēlā parādīts, kā iepriekš minētajā programmā izmantotais 3-D masīvs tiek saglabāts atmiņā.

Rādītāja abonēšana uz masīvu

Pieņemsim arr ir 2-D masīvs ar 3 rindām un 4 kolonnām un ptr ir rādītājs uz 4 veselu skaitļu masīvu un ptr satur masīva bāzes adresi arr .

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

Kopš ptr ir rādītājs uz pirmās rindas 2-D masīvu, t.i., 4 veselu skaitļu masīvu, ptr + i norādīs uz i ^th rinda. Par atsauces atcelšanu ptr + i , mēs iegūstam i bāzes adresi ^th rinda. Lai piekļūtu j adresei ^th i elements ^th rindā rādītāja izteiksmei varam pievienot j *(ptr+i) . Tātad rādītāja izteiksme *(ptr + i) + j norāda j adresi ^th i elements ^th rinda un rādītāja izteiksme **(*(ptr+i)+j) dod j vērtību ^th i elements ^th rinda.
Mēs zinām, ka rādītāja izteiksme *(*(ptr + i) + j) ir ekvivalenta apakšindeksi izteiksmei ptr[i][j]. Tātad, ja mums ir rādītāja mainīgais, kas satur 2-D masīva bāzes adresi, mēs varam piekļūt masīva elementiem, dubultā parakstot šo rādītāja mainīgo.

Piemērs

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

Izvade

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