Wir wissen, dass die Zeigervariable die Speicheradresse in der Sprache C speichern kann, und in diesem Artikel erfahren Sie, wie Sie diesen Zeiger verwenden, um auf die Daten zuzugreifen, die an dem Speicherort gespeichert sind, auf den der Zeiger zeigt.
Was ist ein Zeiger?
Zunächst überarbeiten wir, was ein Zeiger ist. Ein Zeiger ist eine Variable, die die Speicheradresse einer anderen Variablen speichert. Der Zeiger hilft uns, die Daten in der Speicheradresse zu manipulieren, auf die der Zeiger zeigt. Darüber hinaus können mehrere Zeiger auf denselben Speicher verweisen.
Betrachten Sie das folgende Beispiel:
int num = 10; int *ptr; ptr = #>
Wir haben die Adresse des gespeichert Auf eins Variable in der ptr Zeiger, aber jetzt, wie man auf den Wert zugreift, der im Speicher an der Adresse gespeichert ist, auf die verwiesen wird ptr ? Hier kommt die Dereferenzierung ins Spiel.
Dereferenzierungszeiger in C
Der Zugriff auf oder die Manipulation des Inhalts, der in der Speicheradresse gespeichert ist, auf die der Zeiger zeigt, mithilfe eines Dereferenzierungs- oder Indirektionsoperators (*) wird als Dereferenzierung des Zeigers bezeichnet.
Dereferenzierungszeiger in C
Syntax zum Dereferenzieren eines Zeigers
Wir verwenden den Indirektionsoperator (*) als Präfix, um einen Zeiger zu dereferenzieren:
Python schreibt JSON in eine Datei
* ( pointer_name )>
Zum Ändern der im Speicher abgelegten Daten verwenden wir
* ( pointer_name ) = new_value;>
Es ist zu beachten, dass der neue_Wert vom gleichen Typ sein muss wie der vorherige.
Betrachten Sie die obigen Beispiele, wo ptr verweist auf ob, t Auf den Inhalt der Speicheradresse kann mit dem Dereferenzierungsoperator * zugegriffen werden. Nun ruft der *ptr den Inhalt ab, der unter der Adresse 10 gespeichert ist.
Die Speicheradressen und -werte für „num“ und „ptr“ sehen folgendermaßen aus.
| Variable | Speicheradresse | Wert |
|---|---|---|
| Anzahl = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Notiz: Wir haben angenommen, dass die Architektur im obigen Beispiel byteadressierbar ist, d. h. die kleinste Einheit mit einer separaten Adresse ist ein Byte.
Beispiele für die Dereferenzierung von Zeigern
Beispiel 1:
Verwenden eines Zeigers, um auf den Wert einer ganzzahligen Variablen zuzugreifen und ihn zu ändern.
C
// C Program to illustrate the dereferencing of pointer> #include> int> main()> {> >// Declare integer variable number> >int> num = 10;> >// Declare pointer to store address of number> >int>* ptr = #> >// Print the value of number> >printf>(>'Value of num = %d
'>, num);> >// Print Address of the number using & operator> >printf>(>'Address of num = %d
'>, &num);> >// Print Address stored in the pointer> >printf>(>'Address stored in the ptr = %p
'>, ptr);> >printf>(>'Dereference content in ptr using *ptr
'>);> >// Access the content using * operator> >printf>(>'Value of *ptr = %d
'>, *ptr);> >printf>(>'Now, *ptr is same as number
'>);> >printf>(>'Modify the value using pointer to 6
'>);> >// Modify the content in the address to 6 using pointer> >*ptr = 6;> >// Print the modified value using pointer> >printf>(>'Value of *ptr = %d
'>, *ptr);> >// Print the modified value using variable> >printf>(>'Value of number = %d
'>, num);> >return> 0;> }> |
>
>
Ausgabe
bash if-Anweisung
Value of num = 10 Address of num = 0x7ffe47d51b4c Address stored in the ptr = 0x7ffe47d51b4c Dereference content in ptr using *ptr Value of *ptr = 10 Now, *ptr is same as number Modify the value using pointer to 6 Value of *ptr = 6 Value of number = 6>
Beispiel 2: Dereferenzieren eines Doppelzeigers
Die Doppelzeiger können mit derselben Logik auch dereferenziert werden, Sie müssen den Indirektionsoperator jedoch zweimal verwenden: Zum einen, um zu dem Zeiger zu gelangen, auf den der Doppelzeiger zeigt, und zum anderen, um auf den tatsächlichen Wert zuzugreifen.
C
Programmierung in C-Arrays
// C program to dereference double pointer> #include> int> main()> {> >int> var = 10;> >int>* ptr = &var;> >// double pointer> >int>** dptr = &ptr;> >// dereferencing the double pointer> >printf>(>'Accesing value from double pointer using '> >'**dptr: %d'>,> >**dptr);> >return> 0;> }> |
>
>Ausgabe
Accesing value from double pointer using **dptr: 10>
Auf diese Weise können wir Zeiger jeder Ebene dereferenzieren.
Wie funktioniert die Dereferenzierung?
Immer wenn wir den Compiler auffordern, einen Zeiger zu dereferenzieren, führt er drei Dinge aus:
- Es sucht zunächst nach der im Zeiger gespeicherten Adresse.
- Dann sucht es nach dem Typ des Zeigers, um die Menge des zu lesenden Speichers abzuleiten. Zum Beispiel 4 Bytes für int, 1 Byte für char usw. Dies ist auch der Hauptgrund, warum wir den Zeigertyp in der Deklaration angeben müssen, obwohl die Größe jedes Zeigers in einem System gleich ist.
- Schließlich liest es den Speicher und gibt die gespeicherten Daten zurück.
Notiz: Aus der obigen Überlegung können wir auch schließen, dass wir den void-Zeiger nicht dereferenzieren können, da die Größe der Daten, auf die er zeigt, unbekannt ist. Daher müssen wir den void-Zeiger typisieren, um ihn zu dereferenzieren.