Constant Pointers & Pointers Naar Constanten In C Meesteren

In C is een pointer een variabele die het geheugenadres van een andere variabele opslaat, en het const keyword wordt gebruikt om een variabele of pointer te definiëren wiens waarde niet kan worden gewijzigd na initialisatie. Wanneer we pointers combineren met het const keyword, kunnen we twee dingen controleren:

• Of het adres opgeslagen in de pointer kan veranderen.
• Of de waarde opgeslagen op dat adres kan veranderen.

In dit hoofdstuk bekijken we de drie hoofdvariaties van constante pointers:

• Constante Pointer
• Pointer Naar Constante
• Constante Pointer Naar Constante

Constante Pointer

constante pointer betekent dat de pointer zelf constant is. Eenmaal geïnitialiseerd om naar een geheugenlocatie te wijzen, kan het niet naar een andere locatie wijzen, maar de waarde opgeslagen op die locatie kan nog gewijzigd worden.

Hieronder volgt de syntax van een constante pointer:

data_type *const pointer_naam = &variabele;

In deze syntax is data_type het type data waar de pointer naar wijst, *const maakt de pointer zelf constant, pointer_naam is de naam van de pointer, en &variabele wijst het het geheugenadres van een variabele toe.

Voorbeeld Van Een Constante Pointer

In dit voorbeeld declareren we een constante pointer ptr en initialiseren hem met het adres van variabele x. Vervolgens wijzigen we de waarde van x via ptr en printen de waarde.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // constante pointer naar int
    printf("Waarde van x: %d\n", *ptr);
    *ptr = 15; // kan de waarde op het adres wijzigen
    printf("Gewijzigde waarde van x: %d\n", *ptr);
    // ptr = &y; // pointer adres wijzigen is niet toegestaan
    return 0;
}

Hieronder is de output van het bovenstaande programma, die toont dat de pointer vast blijft aan x, maar de waarde van x kan worden bijgewerkt.

Waarde van x: 10
Gewijzigde waarde van x: 15

Voorbeeld Van Een Constante Pointer Fout

Hier is een voorbeeld waar we een constante pointer ptr declareren en initialiseren met het adres van variabele x. Vervolgens proberen we hem te laten wijzen naar het adres van variabele y. Dit geeft een fout omdat een constante pointer niet naar een andere geheugenlocatie kan wijzen nadat het geïnitialiseerd is.

#include <stdio.h>
int main() {
    int x = 10;
    int y = 20;
    int *const ptr = &x; // constante pointer naar int
    printf("Waarde van x: %d\n", *ptr);
    // Poging om de pointer te laten wijzen naar y
    ptr = &y; // kan het adres van een constante pointer niet wijzigen
    return 0;
}

Je ziet de fout hieronder, die aangeeft dat we het adres van een constante pointer niet kunnen wijzigen.

error: assignment of read-only variable 'ptr'

Pointer Naar Constante

Een pointer naar constante betekent dat de waarde waar hij naar wijst niet gewijzigd kan worden, maar de pointer zelf wel naar verschillende geheugenadressen (of variabelen) kan wijzen.

Hieronder volgt de syntax voor pointer naar constante:

const data_type *pointer_naam = &variabele;
data_type const *pointer = &variabele;

In deze syntax betekent const data_type of data_type const dat de pointer wijst naar een constante waarde, pointer_naam is de naam van de pointer, en &variabele wijst het het adres van een variabele toe.

Voorbeeld Van Pointer Naar Constante

In dit voorbeeld declareren we een pointer ptr die naar een constante waarde wijst en wijzen hem het adres van variabele a toe. Vervolgens laten we de pointer naar een ander adres van variabele b wijzen en printen de waarde.

#include <stdio.h>
int main() {
    int a = 5;
    int b = 30;
    const int *ptr = &a; // pointer naar constante int
    printf("Waarde van a: %d\n", *ptr);
    // *ptr = 10; // we kunnen waarde niet wijzigen via pointer
    ptr = &b; // pointer adres wijzigen
    printf("Wijst nu naar b: %d\n", *ptr);
    return 0;
}

Hieronder is de output van het bovenstaande programma, die de dezelfde pointer naar verschillende variabelen wijzen toont.

Waarde van a: 5
Wijst nu naar b: 30

Voorbeeld Van Een Pointer Naar Constante Fout

Hier is een voorbeeld waar we een pointer naar constante ptr declareren en initialiseren met het adres van variabele a. Vervolgens proberen we de waarde van a via de pointer te wijzigen. Dit geeft een fout omdat een pointer naar constante het wijzigen van de waarde waar hij naar wijst niet toestaat.

#include <stdio.h>
int main() {
    int a = 5;
    const int *ptr = &a; // pointer naar constante int
    printf("Waarde van a: %d\n", *ptr);
    // we kunnen waarde niet wijzigen via pointer naar constante
    *ptr = 10;
    return 0;
}

Onderstaand zie je de output, die een fout toont die aangeeft dat we de waarde niet kunnen wijzigen via een pointer naar constante.

error: assignment of read-only location '*ptr'

Constante Pointer Naar Constante

Een constante pointer naar een constante is een pointer die zijn geheugenadres niet kan wijzigen, en de waarde opgeslagen op dat geheugenadres kan ook niet gewijzigd worden. Beide acties zijn beperkt, dus we kunnen alleen de waarde lezen, niets anders.

Hieronder volgt de syntax voor een constante pointer naar een constante:

const data_type *const pointer_naam = &variabele;

In deze syntax:

• const data_type geeft aan dat de waarde op de geheugenlocatie niet gewijzigd kan worden via de pointer.
• *const pointer_naam betekent dat de pointer zelf na initialisatie niet naar een ander geheugenadres kan wijzen.
• &variabele wijst de pointer toe aan het geheugenadres van de variabele.

Voorbeeld Van Constante Pointer Naar Constante

In dit voorbeeld declareren we een constante pointer naar constante ptr en wijzen hem het geheugenadres van variabele a toe. We printen vervolgens de waarde van a met behulp van de pointer.

#include <stdio.h>
int main() {
    int a = 10;
    const int *const ptr = &a; // constante pointer naar constante
    printf("Waarde van a: %d\n", *ptr);
    // *ptr = 15; // we kunnen waarde niet wijzigen
    // ptr = &b; // we kunnen pointer locatie niet wijzigen
    return 0;
}

Hieronder is de output van het bovenstaande programma:

Waarde van a: 10

Voorbeeld Van Constante Pointer Naar Constante Fout

In dit voorbeeld declareren we een constante pointer naar constante ptr en initialiseren hem met een variabele a. Vervolgens proberen we de waarde via de pointer te wijzigen en ook de pointer naar een andere variabele te laten wijzen. Beide operaties zijn niet toegestaan en resulteren in een compiler fout.

#include <stdio.h>
int main() {
    int a = 10;
    int b = 20;
    const int *const ptr = &a; // constante pointer naar constante
    printf("Waarde van a: %d\n", *ptr);
    // *ptr = 15; // we kunnen waarde niet wijzigen
    // ptr = &b; // we kunnen pointer adres niet wijzigen
    return 0;
}

Onderstaand zie je de output die de fouten toont:

Waarde van a: 10

Verschil Tussen Constante Pointer Types

De volgende tabel toont de verschillen tussen een constante pointer, een pointer naar constante, en een constante pointer naar constante.

int *const p = &x;

const int *p = &x;

const int *const p = &x;

Conclusie

In dit hoofdstuk hebben we constante pointers en pointers naar constanten in C behandeld. Constante pointers fixeren het adres maar staan toe de waarde te wijzigen, pointers naar constante staan toe het adres te wijzigen maar niet de waarde, en constante pointers naar constante beperken beide.