C-pointers onder de knie krijgen

Ontdek de kernconcepten van pointers in C, van geheugenadressen tot praktische voorbeelden en veelgemaakte fouten. Geschreven voor ontwikkelaars die hun begrip willen verdiepen met real-world code.

Pointers zijn een hoeksteen van efficiënt C-programmeren. Voordat we in pointers duiken, laten we eens kijken hoe geheugenadressen in C werken.

Geheugenadressen in C

Als je een variabele var hebt, levert de expressie &var het adres op waar var opgeslagen zit.

Adresmanipulatie komt vaak voor, bijvoorbeeld in scanf():

scanf("%d", &var);

Dit slaat de invoer van de gebruiker direct op in de geheugenlocatie van var. Een snelle demo:

#include <stdio.h>
int main() {
    int var = 5;
    printf("var: %d\n", var);
    printf("adres van var: %p", &var);
    return 0;
}

Output

var: 5
adres van var: 0x7fffc1a2b1c8

Let op: Het adres verschilt bij elke run en op elk systeem.

Wat is een pointer?

Een pointer is een variabele die een geheugenadres opslaat in plaats van een conventionele waarde. Door adressen op te slaan, laten pointers indirecte toegang tot data toe, wat dynamisch geheugenbeheer, efficiënte datastructuren en low-level systeemcontrole mogelijk maakt.

Pointers declareren

Typische declaratiesyntaxis:

int *p;

Variaties zijn ook gangbaar:

int *p1; int *p2;

Let op dat de spaties rondom de asterisk de declaratie niet beïnvloeden. Wees echter voorzichtig met komma-gescheiden declaraties:

int *p1, p2; /* p1 is een pointer, p2 is een int */

Adressen toewijzen aan pointers

Voorbeeld:

int *pc, c;
c = 5;
pc = &c;

Hier ontvangt c de waarde 5, en pc slaat het adres van c op.

Pointers derefereren

Om toegang te krijgen tot de waarde die op het adres staat waar een pointer naar wijst, gebruik je de dereferentie-operator *:

int *pc, c;
c = 5;
pc = &c;
printf("%d", *pc); /* Print 5 */

Onthoud: pc is de pointer; *pc haalt de waarde op waar hij naar wijst. Een poging om een adres toe te kennen aan *pc (bijv. *pc = &c;) is ongeldig.

De *-operator heet de dereferentie-operator.

Waarden wijzigen via pointers

Je kunt de onderliggende data wijzigen via zijn pointer:

int *pc, c;
c = 5;
pc = &c;
*pc = 1; /* c wordt 1 */
printf("%d", c); /* Print 1 */

Meerdere variabelen kunnen dezelfde pointer delen na hertoewijzing:

int *pc, c, d;
c = 5;
d = -15;
pc = &c;
printf("%d", *pc); /* 5 */
pc = &d;
printf("%d", *pc); /* -15 */

Praktisch voorbeeld

Draai dit complete programma om te zien hoe pointer-waarden constant blijven terwijl de data waar ze naar wijzen kan veranderen:

#include <stdio.h>
int main() {
    int *pc, c;
    c = 22;
    printf("Adres van c: %p\n", &c);
    printf("Waarde van c: %d\n\n", c);
    pc = &c;
    printf("Adres van pointer pc: %p\n", pc);
    printf("Inhoud van pointer pc: %d\n\n", *pc);
    c = 11;
    printf("Adres van pointer pc: %p\n", pc);
    printf("Inhoud van pointer pc: %d\n\n", *pc);
    *pc = 2;
    printf("Adres van c: %p\n", &c);
    printf("Waarde van c: %d\n\n", c);
    return 0;
}

Output

Adres van c: 0x7fffc1a2b1c8
Waarde van c: 22
Adres van pointer pc: 0x7fffc1a2b1c8
Inhoud van pointer pc: 22
Adres van pointer pc: 0x7fffc1a2b1c8
Inhoud van pointer pc: 11
Adres van c: 0x7fffc1a2b1c8
Waarde van c: 2

Uitleg

1. int *pc, c; – declareert een pointer pc en een int c.
2. c = 22; – slaat 22 op in c's geheugen.
3. pc = &c; – laat pc naar c wijzen.
4. c = 11; – werkt de waarde bij via directe toegang.
5. *pc = 2; – verandert de waarde via de pointer.

Veelgemaakte fouten met pointers

Typische fouten zijn het verwarren van pointers en waarden:

int c, *pc; // Fout – wijst een waarde toe aan een pointer
pc = c; // Fout
// Fout – probeert een adres toe te kennen aan de gedereferenteerde pointer
*pc = &c; // Fout
// Correct – wijs adres toe aan pointer
pc = &c; // OK
// Correct – wijs waarde toe aan de locatie waar de pointer naar wijst
*pc = c; // OK

Voor beginners kan de syntaxis int *p = &c; verwarrend zijn. Het is equivalent aan:

int *p;
p = &c;

Het schrijven als int* p = &c; vermindert de ambiguïteit.

Nu je pointers begrijpt, ben je klaar om hun relatie met arrays in de volgende tutorial te verkennen.