In diesem Artikel geht es um das Zeiger-zu-Zeiger-Konzept in C++. Der Zeiger auf Zeiger zeigt oder speichert die Adresse eines anderen Zeigers und ermöglicht die Manipulation der Zeiger selbst. Mit diesem Konzept können wir einen Zeiger leicht von einer anderen Stelle im Speicher aus ändern. Doppelzeiger sind in dynamisch zugewiesenem Speicher oder mehrdimensionalen Arrays von Vorteil, um die Elemente eines Arrays zu manipulieren. Wir werden diesen Zeiger auf die Funktionsweise und Verwendung von Zeigern in C++ anhand geeigneter Beispiele besprechen.
Szenario 1: Speicherdarstellung von Zeiger zu Zeiger
In diesem Szenario ähnelt die Deklaration des Doppelzeigers der Zeigerdeklaration mit einem zusätzlichen Sternchen (*) vor dem Zeigernamen. Wir können den Speicherort eines Doppelzeigers in C++ leicht darstellen. Der Codeausschnitt des Zeigers auf den Zeiger ist im Folgenden angegeben:
#include
Verwenden des Namensraums std;
int main ( )
{
int Ziffer = fünfzig ;
int * ptrr;
ptrr = & Ziffer;
int ** ptrr1;
ptrr1 = & ptrr;
cout << „Die Zeigerspeicheradresse lautet: \N ' ;
cout << „ptrr (Zeiger):“ << ptrr << ' \N ' ;
cout << „*ptrr1 (Doppelzeiger):“ <<* ptrr1 << ' \N ' ;
cout << „Der im Zeiger gespeicherte Wert ist: \N ' ;
cout << '*ptrr = ' <<* ptrr << endl;
cout << '**ptrr1 (Zeiger auf Zeiger) = ' <<** ptrr1 << endl;
zurückkehren 0 ;
}
In der Hauptfunktion nehmen wir eine Variable, deren Speicheradresse in einem Zeiger gespeichert werden muss. Jetzt initialisieren wir die Variable „digit“. Danach deklarieren wir den „ptrr“-Zeiger, der die „digit“-Speicheradresse speichert. Jetzt deklarieren wir den Doppelzeiger mit dem Namen „**ptrr1“, der die Adresse des „*ptrr“-Zeigers speichert. Am Ende des Codes zeigen wir den Speicher und den Wert des Zeigers und Doppelzeigers auf dem Konsolenbildschirm an. Die Ausgabe dieses Codes wird im Folgenden erwähnt:
Die Speicheradresse des „ptrr“-Zeigers ist „0x6ffe04“, und der „*ptrr1“-Zeiger speichert auch die Speicheradresse des „ptrr“-Zeigers. Der im Zeiger gespeicherte Wert ist „50“. Grundsätzlich ist die Adresse des Doppelzeigers immer dieselbe wie die Speicheradresse des Zeigers.
Szenario 2: Zeiger auf Zeiger als Funktionsparameter
In diesem Szenario lernen wir, wie man den Doppelzeiger in einer beliebigen Funktion als Parameter übergibt, um die temporäre Speicherzuweisung in einer beliebigen Variablen durchzuführen. Der Codeausschnitt des Funktionsparameters mit Doppelzeiger wird im Folgenden erwähnt:
#include
void getMemoryAddress ( int ** double_ptr ) {
du wetterst = 200 ;
* double_ptr = & Temperatur;
}
int main ( ) {
int * ptr_1;
int ** double_ptr;
double_ptr = & ptr_1;
getMemoryAddress ( double_ptr ) ;
std::cout << „Wert von **double_ptr ist:“ << ** double_ptr << std::endl;
zurückkehren 0 ;
}
Hier erfahren wir, wie das Zeiger-zu-Zeiger-Konzept in C++ funktioniert. Denken Sie daran, dass im Programm ein Zeiger deklariert ist, der mit einem Doppelzeiger zusammenarbeitet. Also erstellen wir die Funktion „getMemoryAddress“. Wir entwerfen diese Funktion so, dass sie bei der Übergabe des Parameters automatisch die Speicheradresse des Doppelzeigers erhält.
In der Funktion nehmen wir die Variable „tempp“ und den Doppelzeiger „**double_ptr“. Wir übergeben die Adresse der angegebenen Variablen, die „temp“ ist, an den Doppelzeiger und die Doppelzeigerwerte als Argument der Funktion. Das Programm zeigt das Ergebnis des Hauptfunktionscodes auf dem Konsolenbildschirm an, sodass alle Dinge, die in der Hauptfunktion enthalten sind, ausführbar sind. Wir nehmen den Zeiger „ptr_1“ und den Doppelzeiger als „double_ptr“ in der Hauptfunktion. Wir übergeben die Adresse des Zeigers an den Doppelzeiger.
Jetzt übergeben wir die Doppelzeigervariable in der Override-Funktion und übergeben den Zeiger auf die Zeigervariable in der Ausgabestream-Anweisung „cout“, um das Ergebnis des Doppelzeigers anzuzeigen.
Wenn der Compiler die Override-Funktion erreicht, führt der Compiler-Prüfer, in dem diese Funktion definiert ist, den Code innerhalb der Funktion aus und gibt das Ergebnis an die Hauptfunktion zurück.
Die Ausgabe dieses Codes ist im Folgenden beigefügt:
Ergebnis: Der Wert des Doppelzeigers beträgt 200.
Szenario 3: Verwendung des 2D-Arrays mit Zeiger auf Zeiger
In diesem Beispiel beschäftigen wir uns mit einem 2D-Array mit einem Doppelzeiger. Wir nehmen ein Array und übergeben die Adresse eines Arrays im Zeiger. Der vollständige Code dieses Szenarios wird wie folgt bereitgestellt:
int main ( ) {const int rows = 3 ;
const int cols = 2 ;
int ** Matrix = neue int * [ Reihen ] ;
für ( int i = 0 ; ich < Reihen; ++i ) {
Matrix [ ich ] = neue int [ Spalten ] ;
}
für ( int i = 0 ; ich < Reihen; ++i ) {
für ( int j = 0 ; J < Spalten; ++j ) {
Matrix [ ich ] [ J ] = ich * Spalten + j;
}
}
für ( int i = 0 ; ich < Reihen; ++i ) {
für ( int j = 0 ; J < Spalten; ++j ) {
cout << Matrix [ ich ] [ J ] << ' ' ;
}
cout << endl;
}
für ( int i = 0 ; ich < Reihen; ++i ) {
löschen [ ] Matrix [ ich ] ;
}
löschen [ ] Matrix;
zurückkehren 0 ;
}
Wie wir alle wissen, haben wir viele Zeilen und mehrere Spalten in einem 2D-Array. In der Hauptfunktion initialisieren wir die Zeilen und Spalten, die „const int“ haben. Danach weisen wir den Speicherplatz für die Zeilen und den Speicherplatz für die Spalten entlang jeder Zeile zu. Wir übergeben den Wert für die Anzahl der Zeilen als Zeiger im Matrix-Doppelzeiger als „**Matrix“. In diesem Doppelzeiger gibt die Schleife an, wie viele Zeilen ausgeführt werden oder wahr sind. Anschließend wird eine weitere innere Schleife ausgeführt, bis die Bedingung falsch wird.
Nach der Speicherzuweisung weisen wir einem Array erneut einen Wert zu: eine äußere Schleife für die Zeilen und eine innere Schleife für die Spalten des 2D-Arrays. In der inneren Schleife wird der Wert von Zeilen und Spalten dem Doppelzeiger zugewiesen und führt eine erforderliche Rechenoperation aus. Wir zeigen die Werte eines 2D-Arrays an, beispielsweise die Anzahl der Zeilen und Spalten, die im Speicher zugewiesen sind. Die Anzahl der Zeilen und Spalten zeigt immer auf den Doppelzeiger, der die Zeilen- und Spaltenwerte speichert. Am Ende räumen wir den Speicher auf und geben dieses Array aus dem Speicher in C++ frei.
Die Ausgabe des 2D-Arrays mit einem Doppelzeiger ist im Folgenden angehängt:
Szenario 4: Zeiger mithilfe von Zeiger zu Zeiger austauschen
Hier erfahren wir, wie man die Zeiger in C++ austauscht, indem man den Doppelzeiger deklariert. Der Codeausschnitt dieses Szenarios ist im Folgenden beigefügt:
#includeLeerer Tausch ( int ** ptrr_1, du ** ptrr_2 ) {
int * temp_var = * ptrr_1;
* ptrr_1 = * ptrr_2;
* ptrr_2 = temp_var;
}
int main ( ) {
int x = fünfzehn , y = 25 ;
int * ptrrA = & X, * ptrrB = & Und;
std::cout << „Vor dem Tausch: *ptrrA is =“ << * ptrrA << ', *ptrrB is = ' << * ptrrB << std::endl;
tauschen ( & ptrrA, & ptrrB ) ;
std::cout << „Nach dem Tausch: *ptrrA is = „ << * ptrrA << ', *ptrrB is= ' << * ptrrB << std::endl;
zurückkehren 0 ;
}
Zuerst erstellen wir die Swap-Funktion und übergeben beide Zeiger als Funktionsargument. In der Swap-Funktion nehmen wir den „temp“-Zeiger und übergeben für einige Zeit den Wert von „pointer1“ in „temp“. Dann übergeben wir den Wert von „pointer2“ an „pointer1“. Am Ende übergeben wir den Wert des Zeigers „temp“ an „pointer2“.
In der Hauptfunktion benötigen wir zwei Zeiger, die wir in der Funktion „swap“ übergeben oder überschreiben. Wir übergeben die Adressen von Variablen an die angegebenen Zeiger. Anschließend wird der Wert des Zeigers vor und nach dem Vertauschen des Zeigers angezeigt.
Die Ausgabe dieses Codes ist im Folgenden beigefügt:
Wie wir sehen können, werden die Zeigerwerte mithilfe eines Doppelzeigers in C++ erfolgreich ausgetauscht.
Abschluss
Wir kamen zu dem Schluss, dass der Zeiger auf einen Zeiger immer die Speicheradresse eines beliebigen Zeigers in C++ speichert. Wir können den Doppelzeiger verwenden, um jederzeit vorübergehend den Speicherort eines beliebigen Zeigers zu verwenden. Dies ist eine sehr effektive Möglichkeit, die Speicheradresse indirekt zu manipulieren und an die Daten heranzukommen.