Beheersing van constante pointers en pointers naar constanten in C

In C:een aanwijzer is een variabele die het geheugenadres van een andere variabele opslaat, en het const trefwoord wordt gebruikt om een variabele of pointer te definiëren waarvan de waarde niet meer kan worden gewijzigd nadat deze is geïnitialiseerd. Wanneer we aanwijzers combineren met const trefwoord, kunnen we twee dingen controleren −

• Of het adres dat in de aanwijzer is opgeslagen, kan veranderen.
• Of de waarde die op dat adres is opgeslagen, kan veranderen.

In dit hoofdstuk zullen we kijken naar de drie belangrijkste varianten van constante wijzers −

• Constante aanwijzer
• Wijzer naar constante
• Constante aanwijzer naar constante

Constante aanwijzer

Een constante aanwijzer betekent dat de aanwijzer zelf constant is. Als het eenmaal is geïnitialiseerd om naar een geheugenlocatie te verwijzen, kan het niet naar een andere locatie verwijzen, maar de waarde die op die locatie is opgeslagen, kan nog steeds worden gewijzigd.

Hieronder volgt de syntaxis van een constante aanwijzer −

data_type *const pointer_name = &variable;

In deze syntaxis is data_type is het type gegevens waarnaar de aanwijzer verwijst, *const maakt de aanwijzer zelf constant, pointer_name is de naam van de aanwijzer, en &variabele wijst het het geheugenadres van een variabele toe.

Voorbeeld van constante aanwijzer

In dit voorbeeld declareren we een constante pointer ptr en initialiseer het met het adres van variabele x . Vervolgens veranderen we de waarde van x met behulp van ptr en we drukken de waarde ervan af.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 *ptr = 15; // can change the value at address
 printf("Modified value of x: %d\n", *ptr);
 // ptr = &y; // changing pointer address is not allowed
 return 0;
}

Hieronder wordt de uitvoer weergegeven van het bovenstaande programma, waaruit blijkt dat de aanwijzer op x blijft staan , maar de waarde van x kan worden bijgewerkt.

Value of x: 10
Modified value of x: 15

Voorbeeld van een constante pointerfout

Hier is een voorbeeld waarin we een constante pointer ptr declareren en initialiseer het met het adres van variabele x . Vervolgens proberen we het te laten verwijzen naar het adres van de variabele y . Dit geeft een fout omdat een constante pointer niet naar een andere geheugenlocatie kan verwijzen nadat deze is geïnitialiseerd.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 // Attempting to change the pointer to point to y
 ptr = &y; // cannot change the address of a constant pointer
 return 0;
}

Je kunt de fout hieronder zien , wat aangeeft dat we het adres van een constante pointer niet kunnen veranderen.

error: assignment of read-only variable 'ptr'

Wijzer naar constante

Een aanwijzer naar constante betekent dat de waarde waarnaar hij verwijst niet kan worden gewijzigd, maar dat de aanwijzer zelf naar verschillende geheugenadressen (of variabelen) kan verwijzen.

Hieronder volgt de syntaxis voor de verwijzing naar constante −

const data_type *pointer_name = &variable;
data_type const *pointer = &variable;

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

Voorbeeld van aanwijzer naar constante

In dit voorbeeld declareren we een pointer ptr die naar een constante waarde verwijst en wijs deze het adres toe van variabele a . Vervolgens laten we de aanwijzer naar een ander adres van variabele b wijzen en print de waarde ervan.

#include <stdio.h>
int main() {
 int a = 5;
 int b = 30;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // *ptr = 10; //we cannot modify value through pointer
 ptr = &b; // canging pointer address
 printf("Now pointing to b: %d\n", *ptr);
 return 0;
}

Hieronder volgt de uitvoer van het bovenstaande programma, waarbij dezelfde aanwijzer naar verschillende variabelen wijst.

Value of a: 5
Now pointing to b: 30

Voorbeeld van een verwijzing naar een constante fout

Hier is een voorbeeld waarin we een verwijzing naar constante ptr declareren en initialiseer het met het adres van variabele a . Vervolgens proberen we de waarde van a te wijzigen via de aanwijzer. Dit geeft een fout omdat een verwijzing naar een constante het niet toestaat de waarde waarnaar deze verwijst te wijzigen.

#include <stdio.h>
int main() {
 int a = 5;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // we cnnot modify value through pointer to constant
 *ptr = 10; 
 return 0;
}

Hieronder ziet u de uitvoer , wat een fout weergeeft wat aangeeft dat we de waarde niet kunnen wijzigen via een verwijzing naar constant.

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

Constante aanwijzer naar constante

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

Hieronder volgt de syntaxis voor een constante verwijzing naar een constante −

const data_type *const pointer_name = &variable;

In deze syntaxis −

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

Voorbeeld van constante aanwijzer naar constante

In dit voorbeeld declareren we een constante verwijzing naar constante ptr en wijs het het geheugenadres van variabele a toe . Vervolgens drukken we de waarde van a af met behulp van de aanwijzer.

#include <stdio.h>
int main() {
 int a = 10;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cannot modify value
 // ptr = &b; // we annot change pointer location
 return 0;
}

Hieronder volgt de uitvoer van bovenstaand programma −

Value of a: 10

Voorbeeld van constante verwijzing naar constante fout

In dit voorbeeld declareren we een constante verwijzing naar constant ptr en initialiseer het met een variabele a . Vervolgens proberen we de waarde via de aanwijzer te wijzigen en proberen we ook de aanwijzer naar een andere variabele te laten verwijzen. Beide bewerkingen zijn niet toegestaan en resulteren in een compilerfout .

#include <stdio.h>
int main() {
 int a = 10;
 int b = 20;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cnnot modify value
 // ptr = &b; // we cannot change pointer address
 return 0;
}

Hieronder ziet u de uitvoer toont de fouten −

Value of a: 10

Verschil tussen typen constante aanwijzers

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

Variatie Definitie Kan het adres worden gewijzigd? Kan de waarde veranderen? Voorbeeldsyntaxis Constante PointerEen pointer waarvan het adres vast is, maar de waarde op dat adres kan worden gewijzigd.NeeJa

int *const p = &x;

Pointer to ConstantEen pointer die naar verschillende adressen kan verwijzen, maar de waarde op de aangewezen locatie niet kan wijzigen.JaNee

const int *p = &x;

Constante Pointer naar ConstantEen pointer waarvan het adres vast is en de waarde op dat adres kan niet worden gewijzigd.NeeNee

const int *const p = &x;

Conclusie

In dit hoofdstuk hebben we constante verwijzingen en verwijzingen naar constante in C besproken. Constante verwijzingen repareer het adres, maar sta het wijzigen van de waarde toe, verwijzingen naar constant toestaan dat het adres wordt gewijzigd, maar niet de waarde, en constante verwijzingen naar constant beperk beide.