Wie wir das bereits wissen „Was ist ein Zeiger?“ Ein Zeiger ist eine Variable, die die Adresse einer anderen Variablen speichert. Der Dereferenzierungsoperator wird auch als Indirektionsoperator bezeichnet und durch (*) dargestellt. Wenn der Indirektionsoperator (*) mit der Zeigervariablen verwendet wird, wird er als bezeichnet Dereferenzieren eines Zeigers. Wenn wir einen Zeiger dereferenzieren, wird der Wert der Variablen zurückgegeben, auf die dieser Zeiger zeigt.
Warum verwenden wir einen Dereferenzierungszeiger?
Die Dereferenzierung eines Zeigers wird aus folgenden Gründen verwendet:
- Es kann verwendet werden, um auf die Daten zuzugreifen oder diese zu manipulieren, die an der Speicherstelle gespeichert sind, auf die der Zeiger zeigt.
- Jede auf den dereferenzierten Zeiger angewendete Operation wirkt sich direkt auf den Wert der Variablen aus, auf die er zeigt.
Beobachten wir die folgenden Schritte zum Dereferenzieren eines Zeigers.
- Zuerst deklarieren wir die Integer-Variable, auf die der Zeiger zeigt.
int x =9;
- Jetzt deklarieren wir die Integer-Zeigervariable.
int *ptr;
- Nach der Deklaration einer ganzzahligen Zeigervariablen speichern wir die Adresse der Variablen „x“ in der Zeigervariablen „ptr“.
ptr=&x;
- Wir können den Wert der Variablen „x“ ändern, indem wir einen Zeiger „ptr“ wie unten angegeben dereferenzieren:
*ptr =8;
Die obige Zeile ändert den Wert der Variablen „x“ von 9 auf 8, da „ptr“ auf die Position „x“ zeigt und die Dereferenzierung von „ptr“, d. h. *ptr=8, den Wert von x aktualisiert.
Lassen Sie uns alle oben genannten Schritte kombinieren:
#include int main() { int x=9; int *ptr; ptr=&x; *ptr=8; printf('value of x is : %d', x); return 0;} Ausgabe
Betrachten wir ein anderes Beispiel.
#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; } Im obigen Code:
- Wir deklarieren zwei Variablen „x“ und „y“, wobei „x“ einen Wert „4“ enthält.
- Wir deklarieren eine Zeigervariable „ptr“.
- Nach der Deklaration einer Zeigervariablen weisen wir dem Zeiger „ptr“ die Adresse der Variablen „x“ zu.
- Da wir wissen, dass „ptr“ die Adresse der Variablen „x“ enthält, ist „*ptr“ dasselbe wie „x“.
- Wir weisen „y“ den Wert von „x“ mit Hilfe der Variablen „ptr“ zu, d. h. y=* ptr anstatt die Variable 'x' zu verwenden.
Hinweis: Wenn wir den Wert von „x“ ändern, ändert sich unserer Meinung nach auch der Wert von „y“, da der Zeiger „ptr“ die Adresse der Variablen „x“ enthält. Dies geschieht jedoch nicht, da „y“ die lokale Kopie des Werts „5“ speichert.
Ausgabe
Betrachten wir ein anderes Szenario.
#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; } Im obigen Code:
- Zuerst deklarieren wir eine „a“-Variable.
- Dann deklarieren wir zwei Zeiger, nämlich ptr1 und ptr2.
- Beide Zeiger enthalten die Adresse einer Variablen „a“.
- Wir weisen dem *ptr1 den Wert „7“ und dem *ptr2 den Wert „6“ zu. Der Endwert von „a“ wäre „6“.
Hinweis: Wenn mehr als ein Zeiger auf denselben Ort zeigt, ist die von einem Zeiger vorgenommene Änderung dieselbe wie die eines anderen Zeigers.
Ausgabe
