Voorwaarde: Introductie van aanwijzingen

Denk eens aan het volgende programma:

C

>

>

In het bovenstaande programma hebben we een aanwijzer ptr dat wijst naar de 0^eelement van de array. Op dezelfde manier kunnen we ook een pointer declareren die naar de hele array kan verwijzen in plaats van slechts één element van de array. Deze aanwijzer is handig als het over multidimensionale arrays gaat.

Syntaxis:

data_type  (* var_name ) [size_of_array];>

Hier:

data_type is het type gegevens dat de array bevat. var_name is de naam van de pointervariabele. size_of_array is de grootte van de array waarnaar de pointer verwijst.

Voorbeeld

int (*ptr)[10];>

Hier ptr is een aanwijzer die naar een array van 10 gehele getallen kan verwijzen. Omdat subscript een hogere prioriteit heeft dan indirectheid, is het noodzakelijk om de indirectie-operator en de aanwijzernaam tussen haakjes te plaatsen. Hier is het type ptr ‘wijzer naar een array van 10 gehele getallen.

Let op: De wijzer die naar de 0 wijst^eelement van array en de pointer die naar de hele array verwijst, zijn totaal verschillend. Het volgende programma laat dit zien:

C

>

>

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

Hier, P wijst naar 0^eelement van de array arr , terwijl ptr is een pointer die naar de hele array verwijst arr .

• Het basistype van P is int terwijl basistype van ptr is ‘een array van 5 gehele getallen’.
• We weten dat de pointer-berekeningen worden uitgevoerd ten opzichte van de basisgrootte, dus als we ptr++ schrijven, dan wordt de pointer ptr wordt 20 bytes vooruit geschoven.

De volgende afbeelding toont de aanwijzer p en ptr. De donkerdere pijl geeft een verwijzing naar een array aan.

Bij het derefereren van een pointer-expressie krijgen we een waarde waarnaar door die pointer-expressie wordt verwezen. De pointer naar een array wijst naar een array, dus als we de verwijzingen ervan verwijderen, zouden we de array moeten krijgen, en de naam van de array geeft het basisadres aan. Dus telkens wanneer van een pointer naar een array geen verwijzingen meer worden gemaakt, krijgen we het basisadres van de array waarnaar deze verwijst.

C

>

>

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

Verwijzing naar multidimensionale arrays

1. Aanwijzers en tweedimensionale arrays

In een tweedimensionale array hebben we toegang tot elk element door twee subscripts te gebruiken, waarbij het eerste subscript het rijnummer vertegenwoordigt en het tweede subscript het kolomnummer. De elementen van de 2D-array zijn ook toegankelijk met behulp van pointernotatie. Stel dat arr een 2D-array is, dan hebben we toegang tot elk element arr[i][j] van de array met behulp van de pointer-expressie *(*(arr + i) + j) . Nu zullen we zien hoe deze uitdrukking kan worden afgeleid.
Laten we een tweedimensionale array nemen arr[3][4] :

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

Omdat het geheugen in een computer lineair is georganiseerd, is het niet mogelijk de 2D-array in rijen en kolommen op te slaan. Het concept van rijen en kolommen is slechts theoretisch; in feite wordt een 2D-array opgeslagen in rij-hoofdvolgorde, dat wil zeggen dat rijen naast elkaar worden geplaatst. De volgende afbeelding laat zien hoe de bovenstaande 2D-array in het geheugen wordt opgeslagen.

Elke rij kan worden beschouwd als een 1D-array, dus een tweedimensionale array kan worden beschouwd als een verzameling eendimensionale arrays die achter elkaar worden geplaatst. Met andere woorden, we kunnen zeggen dat 2D-dimensionale arrays achter elkaar worden geplaatst. Dus hier arr is een array van 3 elementen waarbij elk element een 1-D array van 4 gehele getallen is.
We weten dat de naam van een array een constante pointer is die naar 0 wijst^e1-D array en bevat adres 5000. Sinds arr is een ‘pointer naar een array van 4 gehele getallen’, volgens de pointer-rekenkunde vertegenwoordigt de uitdrukking arr + 1 het adres 5016 en de uitdrukking arr + 2 vertegenwoordigt adres 5032.
Dus dat kunnen we zeggen arr wijst naar de 0^e1-D-array, arr + 1 wijst naar de 1^st1-D-array en arr + 2 wijst naar de 2^nl1D-array.

In het algemeen kunnen we schrijven:

 arr + i Points to ith element of arr ->Wijst naar de 1-D array>

• Omdat arr + i naar i wijst^eonderdeel van arr , bij het derefereren krijgt het i^eonderdeel van arr wat natuurlijk een 1D-array is. Aldus de uitdrukking *(arr + ik) geeft ons het basisadres van i^e1D-array.
• We kennen het, de pointer-expressie *(arr + ik) is equivalent aan de subscript-expressie arr[ik] . Dus *(arr + ik) dat is hetzelfde als arr[ik] geeft ons het basisadres van i^e1D-array.
• Om toegang te krijgen tot een individueel element van onze 2D-array, zouden we toegang moeten hebben tot elke j^eonderdeel van ik^e1D-array.
• Sinds het basistype van *(arr + ik) is int en het bevat het adres van 0^eonderdeel van ik^e1-D-array kunnen we de adressen van volgende elementen in de i krijgen^e1-D-array door gehele waarden toe te voegen *(arr + ik) .
• Bijvoorbeeld *(arr + ik) + 1 vertegenwoordigt het adres van 1^stonderdeel van 1^stonderdeel van ik^e1-D-array en *(arr+i)+2 vertegenwoordigt het adres van 2^nlonderdeel van ik^e1D-array.
• Op dezelfde manier vertegenwoordigt *(arr + i) + j het adres van j^eonderdeel van ik^e1D-array. Door deze uitdrukking te derefereren, kunnen we de j krijgen^eelement van de ik^e1D-array.

Aanwijzers en driedimensionale arrays

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

In een driedimensionale array hebben we toegang tot elk element door drie subscripts te gebruiken. Laten we een 3D-array nemen. We kunnen een driedimensionale array beschouwen als een array van 2D-array, dat wil zeggen dat elk element van een 3D-array wordt beschouwd als een 2D-array. De 3D-array arr kan worden beschouwd als een array die uit twee elementen bestaat, waarbij elk element een 2D-array is. De naam van de array arr is een verwijzing naar de 0^e2D-array.

Dus de pointer-expressie *(*(*(arr + i ) + j ) + k) is equivalent aan de subscriptexpressie arr[i][j][k].
We weten dat de uitdrukking *(arr + i) equivalent is aan arr[i] en dat de uitdrukking *(*(arr + i) + j) equivalent is aan arr[i][j]. We kunnen dus zeggen dat arr[i] het basisadres van i vertegenwoordigt^e2D-array en arr[i][j] vertegenwoordigt het basisadres van de j^e1D-array.

Voorbeeld

mvc met java

Het onderstaande voorbeeld demonstreert het programma om elementen van een 3D-array af te drukken met behulp van pointers.

C

>

>

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

De volgende afbeelding laat zien hoe de 3D-array die in het bovenstaande programma wordt gebruikt, in het geheugen wordt opgeslagen.

Abonnementaanwijzer op een array

Veronderstellen arr is een 2D-array met 3 rijen en 4 kolommen en ptr is een verwijzing naar een array van 4 gehele getallen, en ptr bevat het basisadres van de array arr .

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

Sinds ptr is een verwijzing naar de 2D-array van de eerste rij, dat wil zeggen een array van 4 gehele getallen, ptr + ik zal wijzen naar i^erij. Over dereferentie ptr + ik , we krijgen het basisadres van i^erij. Om toegang te krijgen tot het adres van j^eonderdeel van ik^erij kunnen we j toevoegen aan de pointer-expressie *(ptr + ik) . Dus de pointer-expressie *(ptr + i) + j geeft het adres van j^eonderdeel van ik^erij en de aanwijzerexpressie *(*(ptr + i)+j) geeft de waarde van de j^eonderdeel van ik^erij.
We weten dat de pointer-expressie *(*(ptr + i) + j) equivalent is aan de subscript-expressie ptr[i][j]. Dus als we een pointervariabele hebben die het basisadres van een 2D-array bevat, dan hebben we toegang tot de elementen van de array door die pointervariabele dubbel te abonneren.

Voorbeeld

C

>

>

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