Wie man einen Zeiger c++?

Dereferencing ist eine Technik, um Daten aus einer Speicheradresse zu erhalten, die von einem Zeiger veränderlichen Zeiger gezeigt und manipuliert wird. Ein Veränderbar, das die Adresse eines anderen Mutablens hält, wird als Zeiger bezeichnet. Das (*) Zeichen wird als Dereferenzoperator verwendet. Dereferencing Ein Zeiger tritt immer dann auf. Immer wenn ein Zeiger Derferende ist, wird der Wert des durch den Zeiger dargestellten Mutablens zurückgekehrt. Daher werden wir das Konzept der Dererferenzierung eines Zeigers in C ++ diskutieren, während wir das Ubuntu 20 verwenden.04 System. Lassen Sie uns einen Neuanfang mit dem Erstellen einer Datei in Ubuntu unter Verwendung des Terminals "Touch" -Beanschlag haben. Die Datei wird im Root "Home" -Verzeichy Ihres Geräts erstellt. Es kann in einem der Redakteure geöffnet werden, die Sie in Ihrem System haben. Wir bevorzugen den Editor „Nano“, die leere Datei innerhalb der Terminalkonsole zu öffnen.

$ touch Dereference.CC
$ nano Dereference.CC

Beispiel 01:

Wir müssen mit der Einbeziehung einer Bibliothek „iOstream“ für die Nutzung des Eingangs-Output-Streams in C beginnen++. Das #include -Schlüsselwort wird dafür verwendet. Anschließend wurde ein Standard -Namespace „STD“ dazu gekommen, die Standard -Cout- und CIN -Anweisungen zu verwenden. Alle Arbeiten wurden innerhalb der Main () -Methode durchgeführt. Wir haben eine Ganzzahlvariable „n“ mit dem Wert 1 initialisiert. Ein Zeiger vom Typ Ganzzahl wird "P" verwendet. Die erste Cout -Anweisung wird verwendet, um den Wert der Variablen „n“ auf der Shell über den Zeiger „P) anzuzeigen.Die nächste Cout -Anweisung wird verwendet, um den Wert einer Variablen „n“ auf der Shell anzuzeigen.

#enthalten
Verwenden von Namespace STD;
int main ();
int n = 1;
int* p = & n;
Cout<<"Address of n: "<Cout<<"Value of n: "<<*p<

Sie müssen den neuen Code mit dem neu installierten G ++ - Compiler von Ubuntu für die C ++ - Sprache kompilieren. Ab sofort wurden keine Fehler erkannt. Danach haben wir den Code mit dem "ausgeführt"./A.OUT ”-Befehl und erhielt die Adresse und den Wert der Variablen„ n “mit der Zeiger Dereference.

$ g ++ Dereference.CC
$ ./A.aus

Beispiel 02:

Lassen Sie uns ein anderes Beispiel haben, das etwas anders ist als das obige Beispiel. Das Beispiel wurde also mit demselben Eingangs-Output-Stream-Bibliotheksheader und dem Standard-Namespace „STD“ mit dem Schlüsselwort "Verwenden" gestartet. Jetzt wird die Funktion main () mit der Deklaration und Initialisierung einer String -Variablen „V“ mit dem Zeichenfolgewert „Linux“ gestartet."Danach haben wir einen Zeiger vom Typ String deklariert, um die Derercence durchzuführen und ihn über den" & "-Operator mit der Variablen V" zu beziehen. Die Dereferenzierung wird hier verwendet, um den Wert von einer Variablen über den Zeiger abzurufen. Die einzige Änderung ist der Wert einer Variablen, ich.e., String statt einer Ganzzahl. Die erste Cout -Klausel wird verwendet, um die Adresse einer Variablen „V“ anzuzeigen, und die andere Cout -Anweisung wird verwendet, um den Wert der Variablen „V) anzuzeigen.Sparen wir das Skript und führen unseren Code aus.

#enthalten
Verwenden von Namespace STD;
int main ();
String v = "Linux";
String *p = & v;
Cout<<"Address of v: "<Cout<<"Value of v: "<<*p<

Der Code wurde zusammengestellt. Danach haben wir den einfachen Code ausgeführt und die Adresse und den Wert einer Variablen "V" bei der Verwendung der Derercencing -Methode über den Zeiger erhalten.

$ g ++ Dereference.CC
$ ./A.aus

Beispiel 03:

Lassen Sie uns unseren letzten, aber nicht den geringsten Code mit dem Bibliotheksheader begonnen, ich.e., iostream und der Standard -Namespace „std“ erneut. Wir haben zwei Ganzzahlvariablen innerhalb der Main () -Funktion V1 und V2 deklariert. Während V1 mit dem Wert "5" initialisiert wird. In den ersten beiden Cout -Anweisungen werden die aktuellen Werte von V1 und V2 in der Shell angezeigt, und die dritte zeigt die Zeiger „P“ -Ade an. Die nächste Cout -Erklärung zeigt uns, dass wir jetzt Derference durchführen werden. Wir haben also die Anweisung „p = & v1“ verwendet, um die Adresse einer Variablen V1 an Zeiger P zuzuweisen. Dies nennt man Derferenzierung. Der Zeiger „P“ wird verwendet, um die Adresse und den Wert der variablen V1 auf der Schale über die Cout -Klauseln anzuzeigen. Jetzt weisen wir den Wert des Zeigers „P“ (mit V1) Variablen V2 zu. In der Cout -Anweisung wird der Wert von V2 angezeigt, und der Zeiger „P“ wird mit einem neuen Wert von 10 zugewiesen. Die letzten 4 Aussagen zeigen die neuen oder aktuellen Werte von V1, V2 und Zeiger “P.”

#enthalten
Verwenden von Namespace STD;
int main ();
int v1 = 5, v2;
Cout<<"Value of v1: "<Cout<<"Value of v2: "<int *p;
Cout<<"Value of pointer p: "<Cout<<"************* After using p=&v1 ************** "<p =&v1;
Cout<<"Address of v1: "<Cout<<"Value of v1: "<<*p<v2 =*p;
Cout<<"************* After using v2=*p ************** "<Cout<<"Address of v2: "<*p = 10;
Cout<<"************* After using *p=10 ************** "<Cout<<"Address of p: "<Cout<<"Value of p: "<<*p<Cout<<"Value of v1: "<Cout<<"Value of v2: "<

Die Startwerte von V1 und V2 wurden zusammen mit der Zeigeradresse angezeigt. Nach „p = & v1“ wird die Adresse von „P“ durch die von V1 ersetzt. Nach „v2 =*p“ wird ein Referenzwert von "P" V2 zugewiesen. Mit „*p = 10“ wird der Wert von Zeiger „P“ zu 10 und aufgrund von Derercencing wird auch V1 zu 10. Während v2 und die Adresse des Zeigers gleich sind.

$ g ++ Dereference.CC
$ ./A.aus

Abschluss:

Hier ging es also darum, wie man einen Zeiger in C Dereference erledigt++. Wir haben dieses Konzept verwendet, um die Werte einer Variablen abzurufen und den Wert zu ändern oder zu aktualisieren. Wir hoffen, dass wir Ihnen erfolgreich einfache und leicht verständliche Inhalte bieten.