C++-Zeiger mit Beispielen

Was sind Zeiger?

In C++ verweist ein Zeiger auf eine Variable, die die Adresse einer anderen Variablen enthält. Wie normale Variablen haben Zeiger einen Datentyp. Beispielsweise kann ein Zeiger vom Typ Integer die Adresse einer Variablen vom Typ Integer enthalten. Ein zeichenartiger Zeiger kann die Adresse einer zeichenartigen Variablen 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 den eine andere Variable zeigt.

In diesem C++-Tutorial lernen Sie:

Was sind Zeiger?
Adressen in C++
Zeigerdeklarationssyntax
Referenzoperator (&) und Deferenzoperator (*)
Zeiger und Arrays
NULL-Zeiger
Zeiger von Variablen
Anwendung von Zeigern
Vorteile der Verwendung von Zeigern

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 an der zugewiesenen Stelle gespeichert.

Um den Ort im Computerspeicher zu kennen, an dem die Daten gespeichert sind, stellt C++ das & 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.

Zeigerdeklarationssyntax

Die Deklaration von C++ nimmt die folgende Syntax an:

datatype *variable_name;

Der Datentyp ist der Basistyp des Zeigers, der ein gültiger C++-Datentyp sein muss.
Der variable_name sollte der Name der Zeigervariablen sein.
Das Sternchen, das oben für die Deklaration von Zeigern verwendet wird, ähnelt dem Sternchen, das zur Durchführung von Multiplikationsoperationen verwendet wird. Es ist das Sternchen, das die Variable als Zeiger kennzeichnet.

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 Deferenzoperator (*)

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

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

Zum Beispiel:

Wenn wir eine Variable mit dem Namen num haben, die in der Adresse 0x234 gespeichert ist und den Wert 28 speichert.

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;
}

Ausgabe:

Wie das funktioniert:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Importieren Sie die iostream-Header-Datei. Dadurch können wir die in der Header-Datei definierten Funktionen verwenden, ohne Fehler zu erhalten.
Schließen Sie den std-Namensraum ein, um seine Klassen zu verwenden, ohne ihn aufzurufen.
Rufen Sie die Funktion main() auf. Die Programmlogik sollte innerhalb des Hauptteils dieser Funktion hinzugefügt werden. Das { markiert den Anfang des Funktionskörpers.
Deklarieren Sie eine Integer-Variable x und weisen Sie ihr den Wert 27 zu.
Deklarieren Sie eine Zeigervariable *ip.
Speichere die Adresse der Variablen x in der Zeigervariablen.
Drucken Sie etwas Text auf der Konsole.
Den Wert der Variablen x auf dem Bildschirm ausgeben.
Drucken Sie etwas Text auf der Konsole.
Drucken Sie die Adresse der Variablen x. Der Wert der Adresse wurde in der Variablen ip gespeichert.
Drucken Sie etwas Text auf der Konsole.
Druckwert von gespeichert an der Adresse des Zeigers.
Das Programm sollte bei erfolgreicher Ausführung einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Zeiger und Arrays

Arrays und Zeiger arbeiten nach 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 (&) verwenden sollten.

Zum Beispiel:

p = arr;

Das Obige ist korrekt, da arr die Adresse des 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;

Unten ist eine gültige Operation:

ip = arr;

Nach der obigen Deklaration sind ip und arr äquivalent und teilen sich Eigenschaften. Allerdings kann ip eine andere Adresse zugewiesen werden, aber wir können arr nichts zuweisen.

Beispiel 2:

Dieses Beispiel zeigt, wie ein Array mit Zeigern durchlaufen wird:

#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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Deklarieren Sie eine ganzzahlige Zeigervariable ip.
Deklarieren Sie ein Array namens arr und speichern Sie 6 Integer darin.
Arr der IP zuweisen. IP und arr werden gleichwertig.
Erstellen Sie eine for-Schleife. Die Schleifenvariable x wurde erstellt, um über die Array-Elemente von Index 0 bis 5 zu iterieren.
Drucken Sie die Werte, die an der Adresse der Pointer-IP gespeichert sind. 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 eigenen Zeile gedruckt.
Um den Zeiger nach jeder Iteration zur nächsten int-Position zu bewegen.
Ende der for-Schleife.
Das Programm muss bei erfolgreicher Ausführung etwas zurückgeben.
Ende des Hauptteils der main()-Funktion.

NULL-Zeiger

Wenn keine genaue Adresse zugewiesen werden soll, kann der Zeigervariable eine NULL zugewiesen werden. Dies sollte während der Deklaration erfolgen. Ein solcher Zeiger wird als Nullzeiger bezeichnet. Sein Wert ist Null und wird 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Deklarieren Sie eine Zeigervariable ip und weisen Sie ihr den Wert NULL zu.
Druckt den Wert der Zeigervariablen ip zusammen mit etwas Text auf der Konsole.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Variablenzeiger

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

Der Speicherplatz kann beliebig belegt oder neu belegt werden. Möglich wird dies durch Pointer-Variablen.

Zeigervariablen zeigen auf eine bestimmte Adresse im Computerspeicher, auf die eine andere Variable zeigt.

Es kann wie folgt deklariert werden:

int *p;

Oder,

int* p;

In Ihrem 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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Deklarieren Sie eine Zeigervariable p und eine Variable x mit einem Wert von 30.
Weisen Sie p die Adresse der Variablen x zu.
Den Wert der Zeigervariablen p neben etwas Text auf der Konsole ausgeben.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().

Anwendung von Zeigern

Funktionen in C++ können nur einen Wert zurückgeben. Außerdem werden alle in einer Funktion deklarierten Variablen auf dem Funktionsaufrufstapel zugewiesen. Sobald die Funktion zurückkehrt, werden alle Stapelvariablen zerstört.

Argumente für die Funktion werden als Wert übergeben, und jede Änderung, die an den Variablen vorgenommen wird, ändert nicht den Wert der tatsächlich übergebenen Variablen. Das folgende Beispiel hilft bei der Veranschaulichung dieses Konzepts:-

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;
}

Ausgabe:

Hier ist ein Screenshot des Codes:

Code-Erklärung:

Erstellen Sie einen Prototyp einer Funktion namens test, die zwei ganzzahlige Parameter annehmen wird.
Rufen Sie die Funktion main() auf. Wir werden die Programmlogik in seinen Körper einfügen.
Deklarieren Sie zwei Integer-Variablen a und b, jede mit dem Wert 5.
Drucken Sie etwas Text auf der Konsole. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
Den Wert der Variablen a auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
Den Wert der Variablen b auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
Erstellen Sie eine Funktion namens test(), die die Adressen der Variablen a und b als Parameter übernimmt.
Drucken Sie etwas Text auf der Konsole. Das \n erstellt eine neue Leerzeile, bevor der Text gedruckt wird. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen, nachdem der Text gedruckt wurde.
Den Wert der Variablen a auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
Den Wert der Variablen b auf der Konsole zusammen mit anderem Text ausgeben. Das endl (Endzeile) bewegt den Cursor, um mit dem Drucken in der nächsten Zeile zu beginnen.
Das Programm muss nach erfolgreichem Abschluss einen Wert zurückgeben.
Ende des Hauptteils der Funktion main().
Definieren der Funktion test(). Die Funktion sollte zwei ganzzahlige Zeigervariablen *n1 und *n2 annehmen.
Der Zeigervariable *n1 den Wert 10 zuweisen.
Der Zeigervariable *n2 den Wert 11 zuweisen.
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 wiedergegeben.

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 von der Funktion „test“ aus zugegriffen werden, und daher werden alle an diesen Variablen vorgenommenen Änderungen in der aufrufenden Funktion widergespiegelt 'haupt.'

Vorteile der Verwendung von Zeigern

Hier sind die Vorteile/Vorteile der Verwendung von Zeigern

Zeiger sind Variablen, die die Adresse anderer Variablen in C++ speichern.
Mehr als eine Variable kann geändert und von der Funktion mithilfe von Zeigern zurückgegeben werden.
Speicher kann mithilfe von Zeigern dynamisch zugewiesen und freigegeben werden.
Zeiger helfen bei der Vereinfachung der Komplexität des Programms.
Die Ausführungsgeschwindigkeit eines Programms wird durch die Verwendung von Zeigern verbessert.

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 einem Zeiger die Adresse eines Arrays zuweisen möchten, verwenden Sie kein kaufmännisches Und (&).
Wenn es keine bestimmte Adresse gibt, um eine Zeigervariable zuzuweisen, weisen Sie ihr eine NULL zu.

C++ Dynamische Zuordnung von Arrays mit Beispiel C++ Char-Datentyp mit Beispielen

C Sprache