C ++ - Zeiger

In diesem Tutorial lernen wir anhand von Beispielen, wie Zeiger in C ++ funktionieren und wie sie funktionieren.

In C ++ sind Zeiger Variablen, die die Speicheradressen anderer Variablen speichern.

Adresse in C ++

Wenn wir eine Variable var in unserem Programm haben, gibt uns & var ihre Adresse im Speicher. Beispielsweise,

Beispiel 1: Drucken variabler Adressen in C ++

 #include using namespace std; int main() ( // declare variables int var1 = 3; int var2 = 24; int var3 = 17; // print address of var1 cout << "Address of var1: "<< &var1 << endl; // print address of var2 cout << "Address of var2: " << &var2 << endl; // print address of var3 cout << "Address of var3: " << &var3 << endl; )

Ausgabe

 Adresse von var1: 0x7fff5fbff8ac Adresse von var2: 0x7fff5fbff8a8 Adresse von var3: 0x7fff5fbff8a4

Hier steht 0xam Anfang die Adresse in hexadezimaler Form.

Beachten Sie, dass sich die erste Adresse von der zweiten um 4 Bytes und die zweite von der dritten um 4 Bytes unterscheidet.

Dies liegt daran, dass die Größe einer intVariablen in einem 64-Bit-System 4 Byte beträgt.

Hinweis: Wenn Sie das Programm ausführen, erhalten Sie möglicherweise nicht dieselben Ergebnisse.

C ++ - Zeiger

Wie oben erwähnt, werden Zeiger verwendet, um Adressen anstelle von Werten zu speichern.

So können wir Zeiger deklarieren.

 int *pointVar;

Hier haben wir einen Zeiger pointVar vom intTyp deklariert .

Wir können Zeiger auch folgendermaßen deklarieren.

 int* pointVar; // preferred syntax

Nehmen wir ein weiteres Beispiel für die Deklaration von Zeigern.

 int* pointVar, p;

Hier haben wir einen Zeiger pointVar und eine normale Variable p deklariert.
Hinweis: Der *Operator wird nach dem Datentyp verwendet, um Zeiger zu deklarieren.

Zuweisen von Adressen zu Zeigern

So können wir Zeigern Adressen zuweisen:

 int* pointVar, var; var = 5; // assign address of var to pointVar pointer pointVar = &var;

Hier 5wird der Variablen var zugeordnet. Die Adresse von var wird dem pointVar-Zeiger mit dem Code zugewiesen pointVar = &var.

Abrufen des Werts von der Adresse mithilfe von Zeigern

Um den Wert zu erhalten, auf den ein Zeiger zeigt, verwenden wir den *Operator. Beispielsweise:

 int* pointVar, var; var = 5; // assign address of var to pointVar pointVar = &var; // access value pointed by pointVar cout << *pointVar << endl; // Output: 5

Im obigen Code wird die Adresse von var pointVar zugewiesen. Wir haben das verwendet *pointVar, um den in dieser Adresse gespeicherten Wert abzurufen.

Wenn *es mit Zeigern verwendet wird, wird es als Dereferenzierungsoperator bezeichnet . Es arbeitet mit einem Zeiger und gibt den Wert an, auf den die im Zeiger gespeicherte Adresse zeigt. Das heißt , *pointVar = var.

Hinweis: In C ++ unterscheiden sich pointVar und * pointVar vollständig. Wir können so etwas nicht machen*pointVar = &var;

Beispiel 2: Arbeiten mit C ++ - Zeigern

 #include using namespace std; int main() ( int var = 5; // declare pointer variable int* pointVar; // store address of var pointVar = &var; // print value of var cout << "var = " << var << endl; // print address of var cout << "Address of var (&var) = " << &var << endl << endl; // print pointer pointVar cout << "pointVar = " << pointVar << endl; // print the content of the address pointVar points to cout << "Content of the address pointed to by pointVar (*pointVar) = " << *pointVar << endl; return 0; )

Ausgabe

 var = 5 Adresse von var (& var) = 0x61ff08 pointVar = 0x61ff08 Inhalt der Adresse, auf die pointVar (* pointVar) = 5 zeigt

Arbeiten mit C ++ - Zeigern

Ändern des durch Zeiger angezeigten Werts

Wenn pointVar auf die Adresse von var zeigt, können wir den Wert von var mit * pointVar ändern.

Beispielsweise,

 int var = 5; int* pointVar; // assign address of var pointVar = &var; // change value at address pointVar *pointVar = 1; cout << var << endl; // Output: 1

Hier, pointVar und &varhaben die gleiche Adresse, wird der Wert von var auch geändert, wenn * pointVar geändert wird.

Beispiel 3: Ändern des durch Zeiger angezeigten Werts

 #include using namespace std; int main() ( int var = 5; int* pointVar; // store address of var pointVar = &var; // print var cout << "var = " << var << endl; // print *pointVar cout << "*pointVar = " << *pointVar << endl << endl; cout << "Changing value of var to 7:" << endl; // change value of var to 7 var = 7; // print var cout << "var = " << var << endl; // print *pointVar cout << "*pointVar = " << *pointVar << endl << endl; cout << "Changing value of *pointVar to 16:" << endl; // change value of var to 16 *pointVar = 16; // print var cout << "var = " << var << endl; // print *pointVar cout << "*pointVar = " << *pointVar << endl; return 0; )

Ausgabe

 var = 5 * pointVar = 5 Ändern des Werts von var auf 7: var = 7 * pointVar = 7 Ändern des Werts von * pointVar auf 16: var = 16 * pointVar = 16

Häufige Fehler beim Arbeiten mit Zeigern

Angenommen, wir möchten, dass ein Zeiger varPoint auf die Adresse von var zeigt. Dann,

 int var, *varPoint; // Wrong! // varPoint is an address but var is not varPoint = var; // Wrong! // &var is an address // *varPoint is the value stored in &var *varPoint = &var; // Correct! // varPoint is an address and so is &var varPoint = &var; // Correct! // both *varPoint and var are values *varPoint = var;

Empfohlene Lektüre :