C++-Zeiger mit Beispielen

Was sind Zeiger?

In C++ verweist ein Zeiger auf eine Variable, die die Adresse einer anderen Variablen enthält. Zeiger haben wie reguläre Variablen einen Datentyp. Beispielsweise kann ein Zeiger vom Typ Integer die Adresse einer Variablen vom Typ Integer enthalten. Ein Zeiger vom Typ „Zeichen“ kann die Adresse einer Variablen vom Typ „Zeichen“ enthalten.

Sie sollten einen Zeiger als symbolische Darstellung einer Speicheradresse sehen. Mit Zeigern können Programme Call-by-Reference simulieren. Sie können auch dynamische Datenstrukturen erstellen und bearbeiten. In C++ bezieht sich eine Zeigervariable auf eine Variable, die auf eine bestimmte Adresse in einem Speicher zeigt, auf die eine andere Variable zeigt.

Adressen in C++

Um C++-Zeiger zu verstehen, müssen Sie verstehen, wie Computer Daten speichern.

Wenn Sie in Ihrem C++-Programm eine Variable erstellen, wird ihr Speicherplatz im Computerspeicher zugewiesen. Der Wert dieser Variablen wird am zugewiesenen Speicherort gespeichert.

Um den Speicherort der Daten im Computerspeicher zu ermitteln, stellt C++ Folgendes bereit: & (Referenz-)Operator. Der Operator gibt die Adresse zurück, die eine Variable belegt.

Wenn x beispielsweise eine Variable ist, gibt &x die Adresse der Variablen zurück.

Syntax der Zeigerdeklaration

Die Deklaration von C++ sieht wie folgt auswing Syntax:

datatype *variable_name; 
  • Der Datentyp ist der Basistyp des Zeigers, der ein gültiger C++-Datentyp sein muss.
  • Der Variablenname sollte der Name der Zeigervariablen sein.
  • Das oben für die Zeigerdeklaration verwendete Asterisk ähnelt dem Asterisk, das zur Durchführung einer Multiplikationsoperation verwendet wird. Es ist das Sternchen, das die Variable als Zeiger markiert.

Hier ist ein Beispiel für gültige Zeigerdeklarationen in C++:

int    *x;    // a pointer to integer
double *x;    // a pointer to double
float  *x;    // a pointer to float
char   *ch     // a pointer to a character

Referenzoperator (&) und Rückstellungsoperator (*)

Der Referenzoperator (&) gibt die Adresse der Variablen zurück.

Der Dereferenzierungsoperator (*) hilft uns, den Wert zu ermitteln, der in einer Speicheradresse gespeichert wurde.

Beispielsweise:

Wenn wir eine Variable mit dem Namen num haben, wird sie an der Adresse 0x234 gespeichert und speichert den Wert 28.

Der Referenzoperator (&) gibt 0x234 zurück.

Der Dereferenzierungsoperator (*) gibt 5 zurück.

Beispiel 1:

#include <iostream>
using namespace std;
int main() {
	int  x = 27;  
	int  *ip;        
	ip = &x;       
	cout << "Value of x is : ";
	cout << x << endl;
	cout << "Value of ip is : ";
	cout << ip<< endl;
	cout << "Value of *ip is : ";
	cout << *ip << endl;
	return 0;
}

Ausgang:

Referenzoperator (&) und Rückstellungsoperator (*)

Wie das funktioniert:

Referenzoperator (&) und Rückstellungsoperator (*)

Hier ist ein Screenshot des Codes:

Referenzoperator (&) und Rückstellungsoperator (*)

Code-Erklärung:

  1. Importieren Sie die iostream-Headerdatei. Dadurch können wir die in der Header-Datei definierten Funktionen verwenden, ohne dass Fehler auftreten.
  2. Schließen Sie den std-Namespace ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
  3. Rufen Sie die Funktion main() auf. Die Programmlogik sollte im Hauptteil dieser Funktion hinzugefügt werden. Das { markiert den Anfang des Funktionskörpers.
  4. Deklarieren Sie eine ganzzahlige Variable x und weisen Sie ihr den Wert 27 zu.
  5. Deklarieren Sie eine Zeigervariable *ip.
  6. Speichern Sie die Adresse der Variablen x in der Zeigervariablen.
  7. Drucken Sie einen Text auf der Konsole.
  8. Geben Sie den Wert der Variablen x auf dem Bildschirm aus.
  9. Drucken Sie einen Text auf der Konsole.
  10. Geben Sie die Adresse der Variablen x aus. Der Wert der Adresse wurde in der Variablen ip gespeichert.
  11. Drucken Sie einen Text auf der Konsole.
  12. Druckwert, der an der Adresse des Zeigers gespeichert ist.
  13. Das Programm sollte bei erfolgreicher Ausführung einen Wert zurückgeben.
  14. Ende des Hauptteils der main()-Funktion.

Zeiger und Arrays

Arrays und Zeiger basieren auf einem verwandten Konzept. Bei der Arbeit mit Arrays mit Zeigern sind verschiedene Dinge zu beachten. Der Array-Name selbst bezeichnet die Basisadresse des Arrays. Das bedeutet, dass Sie zum Zuweisen der Adresse eines Arrays zu einem Zeiger kein kaufmännisches Und-Zeichen (&) verwenden sollten.

Beispielsweise:

p = arr;

Das Obige ist korrekt, da arr die Adresse der Arrays darstellt. Hier ist ein weiteres Beispiel:

p = &arr;

Das Obige ist falsch.

Wir können ein Array implizit in einen Zeiger umwandeln. Zum Beispiel:

int arr [20];
int * ip;

Nachfolgend finden Sie eine gültige Operation:

ip = arr;

Nach der obigen Deklaration sind ip und arr gleichwertig und haben gemeinsame Eigenschaften. Allerdings kann ip eine andere Adresse zugewiesen werden, arr können wir jedoch nichts zuweisen.

Beispiel 2:

Dieses Beispiel zeigt, wie man ein Array mithilfe von Zeigern durchläuft:

#include <iostream>
using namespace std;
int main() {
	int *ip;
	int arr[] = { 10, 34, 13, 76, 5, 46 };
	ip = arr;
	for (int x = 0; x < 6; x++) {
		cout << *ip << endl;
		ip++;
	}
	return 0;
}

Ausgang:

Zeiger und Arrays

Hier ist ein Screenshot des Codes:

Zeiger und Arrays

Code-Erklärung:

  1. Deklarieren Sie eine ganzzahlige Zeigervariable ip.
  2. Deklarieren Sie ein Array mit dem Namen arr und speichern Sie darin 6 Ganzzahlen.
  3. Weisen Sie arr der IP zu. IP und arr werden gleichwertig.
  4. Erstellen Sie eine for-Schleife. Die Schleifenvariable x wurde erstellt, um die Array-Elemente von Index 0 bis 5 zu durchlaufen.
  5. Drucken Sie die an der Adresse der Zeiger-IP gespeicherten Werte aus. Pro Iteration wird ein Wert zurückgegeben und es werden insgesamt 6 Wiederholungen durchgeführt. Das endl ist ein C++-Schlüsselwort, das die Endzeile bedeutet. Mit dieser Aktion können Sie den Cursor nach dem Drucken jedes Werts in die nächste Zeile bewegen. Jeder Wert wird in einer einzelnen Zeile gedruckt.
  6. Um den Zeiger nach jeder Iteration auf die nächste int-Position zu bewegen.
  7. Ende der for-Schleife.
  8. Das Programm muss bei erfolgreicher Ausführung etwas zurückgeben.
  9. Ende des main()-Funktionskörpers.

Null Zeiger

Wenn es keine genaue Adresse gibt, die zugewiesen werden soll, kann der Zeigervariablen ein NULL zugewiesen werden. Dies sollte während der Erklärung erfolgen. Ein solcher Zeiger wird als Nullzeiger bezeichnet. Sein Wert ist Null und ist in vielen Standardbibliotheken wie iostream definiert.

Beispiel 3:

#include <iostream>
using namespace std;
int main() {
	int  *ip = NULL;
	cout << "Value of ip is: " << ip;
	return 0;
}

Ausgang:

Null Zeiger

Hier ist ein Screenshot des Codes:

Null Zeiger

Code-Erklärung:

  1. Deklarieren Sie eine Zeigervariable ip und weisen Sie ihr den Wert NULL zu.
  2. Gibt den Wert der Zeigervariablen „ip“ zusammen mit etwas Text auf der Konsole aus.
  3. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
  4. Ende des Hauptteils der main()-Funktion.

Zeiger von Variablen

Mit C++ können Sie Daten direkt aus dem Speicher des Computers bearbeiten.

Der Speicherplatz kann nach Belieben zugewiesen oder neu zugewiesen werden. Dies wird durch Pointer-Variablen ermöglicht.

Zeigervariablen verweisen auf eine bestimmte Adresse im Speicher des Computers, auf die eine andere Variable verweist.

Es kann wie folgt deklariert werden:

int *p;

Oder,

int* p;

Im you-Beispiel haben wir die Zeigervariable p deklariert.

Es enthält eine Speicheradresse.

Das Sternchen ist der Dereferenzierungsoperator, der einen Zeiger auf bedeutet.

Der Zeiger p zeigt auf einen ganzzahligen Wert in der Speicheradresse.

Beispiel 4:

#include <iostream>

using namespace std;
int main() {
	int *p, x = 30;
	p = &x;
	cout << "Value of x is: " << *p;
	return 0;
}

Ausgang:

Zeiger von Variablen

Hier ist ein Screenshot des Codes:

Zeiger von Variablen

Code-Erklärung:

  1. Deklarieren Sie eine Zeigervariable p und eine Variable x mit dem Wert 30.
  2. Weisen Sie p die Adresse der Variablen x zu.
  3. Geben Sie den Wert der Zeigervariablen p zusammen mit etwas Text auf der Konsole aus.
  4. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
  5. Ende des Hauptteils der main()-Funktion.

Anwendung von Zeigern

Funktionen in C++ kann nur einen Wert zurückgeben. Darüber hinaus werden alle in einer Funktion deklarierten Variablen auf dem Funktionsaufrufstapel zugewiesen. Sobald die Funktion zurückkehrt, werden alle Stapelvariablen zerstört.

Funktionsargumente werden als Wert übergeben, und Änderungen an den Variablen ändern nicht den Wert der tatsächlich übergebenen Variablen. Following Ein Beispiel hilft, dieses Konzept zu veranschaulichen:

Beispiel 5:

#include <iostream>

using namespace std;
void test(int*, int*);
int main() {
	int a = 5, b = 5;
	cout << "Before changing:" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;

	test(&a, &b);

	cout << "\nAfter changing" << endl;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	return 0;
}

void test(int* n1, int* n2) {
	*n1 = 10;
	*n2 = 11;
}

Ausgang:

Anwendung von Zeigern

Hier ist ein Screenshot des Codes:

Anwendung von Zeigern

Code-Erklärung:

  1. Erstellen Sie einen Prototyp einer Funktion namens test, die zwei ganzzahlige Parameter akzeptiert.
  2. Rufen Sie die Funktion main() auf. Wir werden die Programmlogik in seinen Körper einfügen.
  3. Deklarieren Sie zwei ganzzahlige Variablen a und b mit jeweils dem Wert 5.
  4. Drucken Sie einen Text auf der Konsole. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
  5. Geben Sie den Wert der Variablen a zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
  6. Geben Sie den Wert der Variablen b zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
  7. Erstellen Sie eine Funktion namens test(), die die Adressen der Variablen a und b als Parameter übernimmt.
  8. Drucken Sie einen Text auf der Konsole. Das \n erstellt eine neue Leerzeile, bevor der Text gedruckt wird. Mit endl (Endzeile) wird der Cursor bewegt, um in der nächsten Zeile nach dem Drucken des Textes mit dem Drucken zu beginnen.
  9. Geben Sie den Wert der Variablen a zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
  10. Geben Sie den Wert der Variablen b zusammen mit anderem Text auf der Konsole aus. Mit endl (Endzeile) wird der Cursor bewegt, um mit dem Drucken in der nächsten Zeile zu beginnen.
  11. Das Programm muss bei erfolgreichem Abschluss einen Wert zurückgeben.
  12. Ende des Hauptteils der main()-Funktion.
  13. Definieren der Funktion test(). Die Funktion sollte zwei ganzzahlige Zeigervariablen *n1 und *n2 annehmen.
  14. Weisen Sie der Zeigervariablen *n1 den Wert 10 zu.
  15. Weisen Sie der Zeigervariablen *n2 den Wert 11 zu.
  16. Ende des Hauptteils der Funktion test().

Obwohl den Variablen a und b innerhalb des Funktionstests neue Werte zugewiesen werden, werden diese nach Abschluss des Funktionsaufrufs nicht in der äußeren Funktion main widergespiegelt.

Die Verwendung von Zeigern als Funktionsargumente hilft dabei, die tatsächliche Adresse der Variablen in der Funktion zu übergeben, und alle an der Variablen vorgenommenen Änderungen werden in der äußeren Funktion widergespiegelt.

Im obigen Fall hat die Funktion „test“ die Adresse der Variablen „a“ und „b“. Auf diese beiden Variablen kann direkt über die Funktion „test“ zugegriffen werden, und daher werden alle an diesen Variablen vorgenommenen Änderungen in der aufrufenden Funktion „main“ widergespiegelt.

Vorteile der Verwendung von Zeigern

Hier sind die Vorteile/Vorteile der Verwendung von Zeigern aufgeführt

  • Zeiger sind Variablen, die die Adresse anderer speichern Variablen in C++.
  • Mithilfe von Zeigern kann eine Funktion mehrere Variablen ändern und zurückgeben.
  • Speicher kann mithilfe von Zeigern dynamisch zugewiesen und freigegeben werden.
  • Zeiger helfen bei der Vereinfachung der KommunikationplexFunktion des Programms.
  • Die Ausführungsgeschwindigkeit eines Programms verbessert sich durch die Verwendung von Zeigern.

Zusammenfassung

  • Ein Zeiger bezieht sich auf eine Variable, die die Adresse einer anderen Variablen enthält.
  • Jeder Zeiger hat einen gültigen Datentyp.
  • Ein Zeiger ist eine symbolische Darstellung einer Speicheradresse.
  • Zeiger ermöglichen es Programmen, Call-by-Reference zu simulieren und dynamische Datenstrukturen zu erstellen und zu manipulieren.
  • Arrays und Zeiger verwenden ein verwandtes Konzept.
  • Der Array-Name bezeichnet die Basis des Arrays.
  • Wenn Sie die Adresse eines Arrays einem Zeiger zuweisen möchten, verwenden Sie kein kaufmännisches Und (&).
  • Wenn es keine spezifische Adresse zum Zuweisen einer Zeigervariablen gibt, weisen Sie ihr einen NULL-Wert zu.