Dereferenzierungszeiger in C++

1. Zeiger in C++
2. Verwenden Sie den Operator &, um die Speicheradresse in C++ abzurufen
3. Deklarieren Sie Zeiger in C++
4. Verwenden Sie den Operator *, um den Zeiger in C++ zu dereferenzieren

Dieses Tutorial ist eine kurze Diskussion über das Dereferenzieren von Zeigern in C++.

Bevor wir zu unserem eigentlichen Thema übergehen, müssen wir zunächst verstehen, was ein Zeiger ist und warum C++-Programmierer auf die Notwendigkeit stoßen.

Zeiger in C++

In C++ werden Variablen als die Speicherorte betrachtet, auf die durch ihre Bezeichner zugegriffen wird. Durch dieses Verfahren ist sich ein Programmierer der physikalischen Adresse des Speichers, in dem diese bestimmte Variable gespeichert ist, nicht bewusst und greift über ihren Identifizierer oder Variablennamen darauf zu.

In C++-Programmen ist der physische Speicher eine Reihe von Speicherzellen, wobei jede Zelle eine Größe von einem Byte hat. Wenn eine Variable mit mehr als einem Byte im Speicher gespeichert wird, nimmt sie aufeinanderfolgende Speicherplätze ein.

Beispielsweise ist eine int-Variable vier Bytes groß, sodass vier aufeinanderfolgende Speicherzellen benötigt werden, um einen ganzzahligen Wert zu speichern.

Wenn eine Variable in C++ deklariert wird, wird ihr benötigter Speicherplatz einer bestimmten Adresse zugewiesen (bekannt als ihre physische Adresse). Dies wird im Allgemeinen während der Laufzeit durch das Betriebssystem oder die Umgebung des Programms entschieden, in der sich diese physikalische Adresse befindet.

Auf diese Speicheradresse kann zugegriffen und sie in einer Variablen gespeichert werden. Für den Zugriff verwenden wir einen Operator, der als Adresse von-Operator bekannt ist und durch das Symbol & gekennzeichnet ist.

Verwenden Sie den Operator &, um die Speicheradresse in C++ abzurufen

Der Operator address-of erhält die Speicheradresse, an der eine bestimmte Variable gespeichert ist. Es wird verwendet, indem dem Variablennamen der Operator & vorangestellt wird.

Siehe das Code-Snippet unten:

addr = &newvar

Dadurch wird der Variablen addr die Adresse der Variablen newvar zugewiesen, nicht aber der Inhalt. Dies ist in der folgenden Abbildung dargestellt.

Beispiel:

newvar = 25;
addr = &newvar

Ausgang:

In diesem Code haben wir zunächst der Variablen newvar den Wert 25 zugewiesen, und newvar wird auf dem Speicherplatz 3 abgelegt. Dann haben wir der Variablen addr die Adresse von newvar zugewiesen.

Die Variable addr, in der wir die Adresse von newvar gespeichert haben, hat also den Wert 3, die Speicheradresse von newvar.

Deklarieren Sie Zeiger in C++

Die Variable, die zum Speichern der Adresse einer anderen Variablen verwendet wird, wird als Zeigervariable bezeichnet. Im obigen Beispiel ist die Variable addr ein Zeiger.

Zeiger sind sehr mächtige Funktionen in der Programmierung. Eine Zeigervariable eines bestimmten Typs zeigt auf eine Variable desselben Typs.

Sie wird mit einem Sternchen (*)-Operator zum Zeitpunkt der Deklaration der Zeigervariablen deklariert. Betrachten Sie das folgende Code-Snippet:

#include <iostream>
using namespace std;

int main() {
  int num = 5;
  int* pNum;

  pNum = &num;
  cout << "Value of num is: " << num << endl;
  cout << "Address of num is: " << pNum << endl;
  return 0;
}

Ausgang:

Die Programmausgabe zeigt den Wert von newvar, der 5 ist, und seine Adresse, die im Zeiger pNum gespeichert ist.

Da Zeiger direkt auf den Variablenwert zeigen können, müssen sie denselben Datentyp haben wie die Variable, auf die sie zeigen.

Syntax:

datatype * nameOfPointer;

Der Datentyp ist hier der Typ der Variablen, auf die er zeigt.

Beispiel:

int* numPtr;
char* charPtr;
double* doublePtr;

In diesem Codeausschnitt gibt es drei Deklarationen von Zeigern, aber sie sind von unterschiedlichem Typ. Sie sollen den gleichen Speicherplatz im Speicher belegen (der Speicherplatz hängt von der Umgebung des Programms ab).

Keiner von ihnen kann auf einen anderen Variablentyp zeigen.

Verwenden Sie den Operator *, um den Zeiger in C++ zu dereferenzieren

Im vorherigen Beispiel haben wir den Operator address-of verwendet, um die Adresse der Variablen im Zeiger zu speichern. Der Dereferenzierungsoperator (*) ruft den Inhalt einer Variablen ab, auf die der Zeiger zeigt.

Wir können den Variablenwert erhalten, dessen Adresse im Zeiger gespeichert ist.

Im folgenden Beispiel greifen wir auf den Wert der Variablen newvar zu, indem wir den Zeiger dereferenzieren und die Variable direkt verwenden. Wir können in der Ausgabe beobachten, dass beide gleich sind.

#include <iostream>
using namespace std;

int main() {
  int num = 5;
  int* pNum;

  pNum = &num;
  cout << "Value of num is: " << num << endl;
  cout << "Address of num is: " << pNum << endl;
  cout << "Value of num by using pointer: " << *pNum << endl;
  return 0;
}

Ausgang:

Wir können den dereferenzierten Wert auch in einer anderen Variablen wie dieser speichern:

num2 = *pNum;

Das bedeutet, dass num2 gleich dem Variablenwert ist, auf den pNum zeigt. Dies wird in der folgenden Abbildung demonstriert.

Hier wird num2 mit dem Dereferenzierungsoperator derselbe Wert wie num zugewiesen.

Erstellt eine Dereferenzierung eine Kopie?

Beim Dereferenzieren wird manchmal eine Kopie erstellt, wenn wir mehr als nur das Dereferenzieren tun. Wenn wir also diesen dereferenzierten Wert verwenden, um eine neue Variable zu initialisieren, ist das eine Kopie, wie im obigen Beispiel gezeigt.

Aber wenn wir den dereferenzierten Wert verwenden und als Referenz in irgendeiner Referenzvariablen speichern, dann ist das keine Kopie, sondern ein Alias wird erstellt.

int num = 5;
int* pNum = #
int& num2 = *pNum;

Der Dereferenzierungsoperator hat in der letzten Zeile die Referenzvariable num2 initialisiert. Diese Referenzvariable num2 enthält nun die Adresse von num und ist ein Alias von num. Es kopiert seinen Wert nicht.

Dies wird in der folgenden Abbildung erläutert.

Nun zeigt num2 auch auf num, weil es die Speicheradresse von num enthält. Somit sind Pointer ein hilfreiches Werkzeug beim Programmieren und ermöglichen uns ein effizientes Speicher- und Zeitmanagement beim Programmieren.