Linux C Programmeer tutorial Deel 21: Karakter-aanwijzers, array van aanwijzers, en pointer naar pointer

Het concept van wijzers is inderdaad een van de zeer belangrijke concepten in de programmeertaal C. Tot nu toe hebben we verschillende aspecten van pointers in C besproken. Daarop voortbordurend zullen we in deze tutorial nog een paar pointer concepten bespreken.

Karakterpointers, array van pointers, en pointer naar pointer in C

Laten we beginnen met karakter-aanwijzers met de volgende regels code:

char p[] = "I like HowtoForge"
char *p = "I like HowToForge"

De eerste regel definieert een array ‘p’ met grootte gelijk aan het aantal tekens tussen dubbele aanhalingstekens. Maar de volgende regel definieert een pointer ‘p’ die naar een stringconstante wijst.

Het verschil hier is dat de eerste ‘p’ een array is, je de inhoud van de array gemakkelijk kunt wijzigen of veranderen. Maar omdat de tweede ‘p’ naar een stringconstante wijst, kun je de stringinhoud net niet veranderen.

Bijvoorbeeld, het volgende stukje code probeert een string constante te veranderen:

#include <stdio.h>

int main()
{
char *p = "I like HowToForge";

p[0] = 'U';

return 0;
}

En hier is de uitvoer die deze code op mijn systeem produceert:

Segmentation fault

Deze foutmelding suggereert dat de programma-uitvoering abrupt tot een einde kwam, en dat komt omdat we iets probeerden te veranderen dat constant is.

Bedenk ook dat je de pointer ‘p’ weliswaar een andere string kunt laten aanwijzen, maar dat je het basisadres van de array ‘p’ niet kunt veranderen (als je je herinnert hebben we dit al besproken in een van onze eerdere leerprogramma’s).

Nu overgaand op pointer arrays, net zoals je integer, karakter en andere soorten arrays gezien hebt, kan er ook een array van pointers zijn. Bijvoorbeeld, het volgende programma definieert een array ‘arr’ van integer wijzers en kent er waarden aan toe.

#include <stdio.h>

int main()
{
int *arr[3];
int a = 0, b = 1, c = 2;

arr[0] = &a;
arr[1] = &b;
arr[2] = &c;

return 0;
}

Merk op dat de waarden die aan de array worden toegekend adressen zijn. Dit komt omdat ‘arr’ een array van pointers is, en pointers slaan niets anders op dan adressen. Wil je nu toegang tot waarden die op deze adressen bewaard worden, dan zul je de *operator moeten gebruiken.

Het volgende voorbeeld (dat niets anders is dan een uitbreiding van het vorige voorbeeld) laat dit zien:

#include <stdio.h>

int main()
{
int *arr[3];
int a = 0, b = 1, c = 2;

arr[0] = &a;
arr[1] = &b;
arr[2] = &c;

for(int i=0; i < 3; i++)
printf("\n arr[%d] is: %d",i,*(arr[i]));

return 0;
}

Hier zie je de uitvoer:

arr[0] is: 0 
arr[1] is: 1
arr[2] is: 2

Vergelijkbaar met integer pointer arrays (zoals die we hier bespraken), kun je arrays hebben die karakterpointers opslaan en meer.

Laten we nu verder gaan met aanwijzers. Zoals we tot nu toe al een aantal keren ge-erteerd hebben, slaat een pointer een adres op. Nu hebben we tot nu toe in deze lopende C programmeer-tutorial serie alleen een pointer gezien die naar een niet-pointer variabele wijst, maar het is een feit dat pointers ook naar andere pointers kunnen wijzen.

Dit betekent dat een pointer een adres van een andere pointer kan opslaan. Bijvoorbeeld, hieronder staat een dubbele pointer of een pointer naar pointer:

int **ptr;

Hier is een stukje code dat gebruik maakt van een dubbele pointer:

#include <stdio.h>

int main()
{
int *ptr;
int **p;

int a = 10;

ptr = &a;

p = &ptr;

printf("\n Pointer 'p' points to pointer 'ptr' which further points to value: %d", **p);

return 0;
}

Hier is de uitvoer:

Pointer 'p' points to pointer 'ptr' which further points to value: 10

Dit was dus een voorbeeld van een dubbele pointer. Op soortgelijke lijnen kun je een pointer naar een pointer hebben, gedefinieerd als, bijvoorbeeld, int ***ptr. Het maximum aantal van zulke ‘pointer to pointer to……’ niveaus is implementatie-specifiek (in sommige gevallen is de limiet echter 12).

Praktisch gezien zul je echter waarschijnlijk alleen pointer to pointers tot niveau drie tegenkomen, want meer niveaus maken de logica ingewikkelder om te begrijpen en te onderhouden.

Conclusie

We hebben hier drie belangrijke pointers gerelateerde begrippen besproken. Je doet er goed aan de voorbeelden en concepten die we hier bespraken op je systeem uit te proberen om een beter idee te krijgen van hoe deze dingen werken. Bij twijfel of vragen, stuur ons een commentaar hieronder.