Zoals wij dat al weten 'Wat is een aanwijzer' , een pointer is een variabele die het adres van een andere variabele opslaat. De dereferentie-operator wordt ook wel een indirectie-operator genoemd, die wordt weergegeven door (*). Wanneer de indirectie-operator (*) wordt gebruikt met de pointervariabele, dan staat deze bekend als het derefereren van een aanwijzer. Wanneer we een pointer derefereren, wordt de waarde van de variabele waarnaar deze pointer verwijst, geretourneerd.
Waarom gebruiken we dereferentiewijzer?
Dereferentie van een aanwijzer wordt gebruikt vanwege de volgende redenen:
- Het kan worden gebruikt om toegang te krijgen tot de gegevens die zijn opgeslagen op de geheugenlocatie, waarnaar wordt verwezen door de aanwijzer, of deze te manipuleren.
- Elke bewerking die wordt toegepast op de aanwijzer waarvan de verwijzing is verwijderd, heeft rechtstreeks invloed op de waarde van de variabele waarnaar deze verwijst.
Laten we de volgende stappen volgen om een aanwijzer te derefereren.
- Eerst declareren we de gehele variabele waarnaar de pointer verwijst.
int x =9;
- Nu declareren we de gehele pointervariabele.
int *ptr;
- Na de declaratie van een pointervariabele met geheel getal slaan we het adres van de variabele 'x' op in de pointervariabele 'ptr'.
ptr=&x;
- We kunnen de waarde van de variabele 'x' wijzigen door een verwijzing naar een pointer 'ptr' te verwijderen, zoals hieronder weergegeven:
*ptr =8;
De bovenstaande regel verandert de waarde van de 'x'-variabele van 9 naar 8 omdat 'ptr' verwijst naar de 'x'-locatie en dereferentie van 'ptr', d.w.z. *ptr=8 zal de waarde van x bijwerken.
Laten we alle bovenstaande stappen combineren:
#include int main() { int x=9; int *ptr; ptr=&x; *ptr=8; printf('value of x is : %d', x); return 0;} Uitvoer
Laten we een ander voorbeeld bekijken.
#include int main() { int x=4; int y; int *ptr; ptr=&x; y=*ptr; *ptr=5; printf('The value of x is : %d',x); printf('
The value of y is : %d',y); return 0; } In de bovenstaande code:
- We declareren twee variabelen 'x' en 'y' waarbij 'x' een '4'-waarde heeft.
- We declareren een pointervariabele 'ptr'.
- Na de declaratie van een pointervariabele wijzen we het adres van de 'x'-variabele toe aan de pointer 'ptr'.
- Omdat we weten dat de 'ptr' het adres van de variabele 'x' bevat, is '*ptr' hetzelfde als 'x'.
- We kennen de waarde van 'x' toe aan 'y' met behulp van de 'ptr'-variabele, d.w.z. y=* ptr in plaats van de variabele 'x' te gebruiken.
Opmerking: als we de waarde van 'x' veranderen, zal volgens ons ook de waarde van 'y' veranderen, omdat de pointer 'ptr' het adres van de variabele 'x' bevat. Maar dit gebeurt niet, omdat 'y' de lokale kopie van waarde '5' opslaat.
Uitvoer
Laten we een ander scenario overwegen.
#include int main() { int a=90; int *ptr1,*ptr2; ptr1=&a; ptr2=&a; *ptr1=7; *ptr2=6; printf('The value of a is : %d',a); return 0; } In de bovenstaande code:
- Eerst declareren we een 'a'-variabele.
- Vervolgens declareren we twee pointers, namelijk ptr1 en ptr2.
- Beide pointers bevatten het adres van de variabele 'a'.
- We kennen de waarde '7' toe aan de *ptr1 en '6' aan de *ptr2. De uiteindelijke waarde van 'a' zou '6' zijn.
Opmerking: als er meer dan één aanwijzer naar dezelfde locatie wijst, zal de wijziging die door één aanwijzer wordt aangebracht hetzelfde zijn als die van een andere aanwijzer.
Uitvoer
