Funktionalität und Unterschied zwischen *& und **& in C++

1. Funktionalität und Unterschied zwischen *& und **& in C++
2. Behandeln Sie Werte durch Zeiger in C++
3. Behandeln von Werten durch Referenzzeiger in C++
4. Behandeln von Werten durch Zeiger auf Zeigerreferenz (Doppelzeiger) in C++

Diese Anleitung erklärt den Unterschied und die Funktionalität von *& und **& in C++. Um diese Symbole zu verstehen, müssen Sie mit dem Konzept der Zeiger in C++ vertraut sein.

Bevor Sie also fortfahren und den gesamten Leitfaden lesen, besuchen Sie den Leitfaden über Hinweise. Sobald Sie dieses Konzept verstanden haben, ist es einfach, diese Anleitung zu verstehen.

Funktionalität und Unterschied zwischen *& und **& in C++

Wenn wir versuchen, Werte per Zeiger zu handhaben, verwenden wir einen Zeiger. Seine Syntax ist *ptr.

Lassen Sie uns dieses ganze Konzept anhand der folgenden Beispiele verstehen.

#include <iostream>
using namespace std;

// global variables
int value_1 = 10, value_2 = 20, *global_ptr;

Wir erstellen einfach zwei Variablen, value_1, value_2, und einen globalen Zeiger als *global_ptr. Als nächstes haben wir drei verschiedene Funktionen und Methoden erstellt, um alles zu verdeutlichen.

Diese Funktionen sind wie folgt.

Behandeln Sie Werte durch Zeiger in C++

// function which handles values by pointer
void byPointer(int *ptr) {
  *ptr = 5;
  ptr = global_ptr;
  *ptr = 3;
}

Die erste Funktion behandelt Werte durch den Zeiger, wie Sie sehen können, dass ihr Parameter ein Zeiger ist.

Im Inneren überschreiben wir einfach den Wert des Zeigers, verweisen auf einen globalen Zeiger und überschreiben später seinen Wert erneut. Sehen wir uns die Funktion main() an.

int main() {
  // a pointer to value 1
  int *ptrValue_1 = &value_1;

  // a global pointer having an address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;

  byPointer(ptrValue_1);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

Zuerst haben wir einen Zeiger erstellt, der auf die Adresse der ersten Variablen zeigt. Der globale Zeiger zeigt auf die Adresse der zweiten Variablen.

Wir übergeben einfach den Zeiger ptrValue_1 an die oben erwähnte Funktion, wie Sie sehen können, dass die Anfangswerte der Variablen value_1 und value_2 10 bzw. 20 sind.

Aber innerhalb der Funktion byPointer() werden diese Werte überschrieben. Der Zeiger zeigt auch auf die Adresse des globalen Zeigers, der auf die Adresse von value_2 zeigt; deshalb wurden beide Werte geändert.

Die Ausgabe des obigen Codes ist:

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 5
Value_2 = 3
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004

Wie Sie sehen können, wurden die Werte beider Variablen geändert, aber sie haben die Adresse der Zeiger nicht geändert. Dies liegt daran, dass es Kopien von Zeigern erstellt und Werte behandelt, indem es die Kopien auf diese Weise der Behandlung von Werten verwendet.

Deshalb bleibt die Adresse unverändert. Dieses Konzept wird Ihnen helfen, weiter zu verstehen.

Behandeln von Werten durch Referenzzeiger in C++

Lassen Sie uns nun das Konzept von *& in C++ verstehen. Sehen Sie sich den folgenden Code an.

// function which handle values by pointer Reference
void byPointerReference(int*& ptr) {
  *ptr = 40;
  ptr = global_ptr;
  *ptr = 50;
}

In der obigen Methode übergeben wir eine Referenz auf einen Zeiger als Parameter. Es funktioniert genauso wie die Funktion, in der wir den Zeiger übergeben haben.

Der einzige Unterschied besteht darin, dass auch die Adresse der Zeiger geändert wird. Nach der Methode ist die Adresse der Zeiger die gleiche wie die Adresse des globalen Zeigers gemäß diesem Code.

int main() {
  // a pointer to value 1
  int *ptrValue_1 = &value_1;

  // a global pointer having the address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;

  byPointerReference(ptrValue_1);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

Die Idee hier ist, Ihnen zu zeigen, dass sich sowohl die Adresse als auch der Wert des Zeigers ändern. Die Ausgabe des obigen Codes ist wie folgt.

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 40
Value_2 = 50
ptrValue_1 = 0x4b8004
global_ptr = 0x4b8004

Behandeln von Werten durch Zeiger auf Zeigerreferenz (Doppelzeiger) in C++

Es funktioniert genauso wie die Einzelzeigerreferenz. Der einzige Unterschied besteht darin, dass es sich um einen Doppelzeiger handelt.

Wenn Sie zum Beispiel ein Geschenk in eine Schachtel packen und das gleiche Geschenk in der Schachtel in einer Schachtel verpacken, wird die andere Person schließlich das Geschenk haben. Es macht keinen Unterschied.

Der einzige Unterschied besteht in der Syntax. Die Doppelzeiger-Referenz geht wie folgt.

int **ptrToptr = &ptrValue_1;

Schauen wir uns die Funktion/Methode an.

void bypointerPointerReference(int**& ptr) {
  **ptr = 40;
  *ptr = global_ptr;
  **ptr = 50;
}

Bis auf die Syntax gibt es keinen Unterschied. Die Hauptfunktion wird wie folgt sein.

int main() {
  // a double pointer to value 1
  int *ptrValue_1 = &value_1;
  int **ptrToptr = &ptrValue_1;

  // a global pointer having an address of value 2

  global_ptr = &value_2;

  // values before calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  bypointerPointerReference(ptrToptr);

  // values after calling function
  cout << "Value_1 = " << value_1 << endl;
  cout << "Value_2 = " << value_2 << endl;

  cout << "ptrValue_1 = " << ptrValue_1 << endl;
  cout << "global_ptr = " << global_ptr << endl;
  return 0;
}

Die Ausgabe ist die gleiche wie oben.

Value_1 = 10
Value_2 = 20
ptrValue_1 = 0x4b8000
global_ptr = 0x4b8004
Value_1 = 40
Value_2 = 50
ptrValue_1 = 0x4b8004
global_ptr = 0x4b8004