Mit Zeigern in C / C++ arbeiten

Wie arbeitet man mit Zeigern in C / C++? Zeiger auf eine Variable zeigen lassen. Wie werden sie dereferenziert? Was ist Zeigerarithmetik?

Um diesen Artikel lesen und verstehen zu können, muss Ihnen klar sein, um was es sich bei Zeigern handelt. Hier erfahren Sie, wie Zeiger in C / C++ eingesetzt werden.

Deklaration von Zeigern in C / C++

Wie alle Variablen werden Zeiger mit einem Namen und einem Datentyp deklariert. Sie müssen allerdings beachten, dass der Datentyp sich nicht wie bei Variablen auf den Inhalt des Zeigers bezieht, sondern den Typ der Variablen angibt, auf welche der Pointer verweist. Ein Stern definiert eine Variable bei der Deklaration als Pointer.

int * myPointer;

Sie definieren in der obigen Anweisung einen Zeiger namens myPointer, der auf eine Variable vom Typ int verweist. Beachten Sie, dass der Stern vor dem Namen die Variable als Zeiger markiert. Nun weiß der Compiler, dass myPointer nur Speicheradressen enthalten kann.

Das Problem ist, dass der Zeiger undefiniert ist. Er zeigt also auf irgendeine Adresse. Da Zeiger nur schwer zu beherrschen sind, sollte jeder Pointer bei der Deklaration sofort initialisiert werden, d.h. er sollte auf einen definierten Speicherbereich zeigen. In C / C++ gibt es den Bereich NULL. NULL ist eine Konstante für die Zahl 0. Wenn Sie einen Zeiger auf NULL setzen, ist sein Ziel ganz klar definiert und er zeigt nicht auf eine Speicheradresse, die an anderer Stelle verwendet wird. Er zeigt dann praktisch auf nichts.

Ihre Deklaration sollte also wie folgt aussehen:

int * myPointer = NULL;

Zeiger auf eine Variable zeigen lassen

Nun haben Sie Ihren Zeiger deklariert und auf NULL gesetzt. Irgendwann im Laufe des Programms werden Sie wollen, dass der Zeiger auf eine Variable verweist. Nun müssen Sie aufpassen. Die folgende Anweisung dürfen Sie nicht schreiben:

int myVar = 5;

myPointer = myVar;

In diesem Fall weisen Sie myPointer den Wert von myVar zu, also 5. Damit wird 5 als Speicheradresse interpretiert, was nicht vorgesehen ist. Sie müssen dem Zeiger explizit die Speicheradresse der Variablen zuweisen. Dies geschieht über den oben erwähnten &-Operator.

myPointer = &myVar;

Nun weiß der Compiler, dass dem Zeiger myPointer die Speicheradresse der Variablen myVar zugewiesen werden soll. Damit zeigt myPointer auf die Variable myVar. Sie können einen Zeiger natürlich jederzeit auf eine andere Variable zeigen lassen. Sie müssen nur beachten, dass Sie dem Pointer die Adresse der Variablen zuweisen und dass die Variable von dem Datentyp ist, den Sie in der Deklaration der Zeigervariablen notiert haben – im Beispiel also int.

Zeiger dereferenzieren

Wenn Sie nun über den Zeiger auf den Wert der referenzierten Variable zugreifen möchten, müssen Sie den Zeiger dereferenzieren. Dies geschieht in C / C++ ebenfalls mit dem Stern. Und an dieser Stelle besteht höchste Verwechslungsgefahr! Denn der Stern bedeutet je nach Kontext etwas Unterschiedliches. Bei der Deklaration markiert er die Variable einfach nur als Zeiger. Beim Zugriff dereferenziert er den Zeiger.

Im folgenden Beispiel wird zuerst die Adresse des Zeigers auf dem Bildschirm ausgegeben, indem mit dem &-Operator auf die Adresse zugegriffen wird. Dann wird die Adresse der Variablen, auf die der Zeiger zeigt, ausgegeben. Da die Adresse der Wert des Zeigers ist, geschieht das genauso wie bei der Ausgabe des Wertes einer gewöhnlichen Variable. Als drittes möchten wir den Wert der Variable sehen, auf die der Pointer zeigt. Und hier erscheint der Stern. Denn es muss dereferenziert werden, da wir nicht den Wert des Zeigers, sondern den Wert der Variablen sehen möchten.

cout << „Die Adresse des Zeiger: “ << &myPointer << endl;

cout << „Die Adresse der Variablen: “ << myPointer << endl;

// Dereferenzierung

cout << „Der Wert der Variablen: “ << *myPointer << endl;

Beispiel

/* Dieses Beispiel zeigt die Verwendung eines einfachen Zeigers.*/

#include

#include

#include

int main()

{

int zahl = 12345; // Eine int-Variable.

int * pZahl = NULL; // Ein Zeiger.

// Der Zeiger zeigt auf die Adresse der Variablen zahl.

pZahl = &zahl;

// Ausgabe der Zahl.

cout << „Die Zahl lautet: “ << zahl << endl;

// Ausgabe der Adresse der Zahl.

cout << „Die Zahl steht an Adresse: “ << &zahl << endl;

// Ausgabe der Adresse des Zeigers.

cout << „Speicheradresse des Zeigers: “ << &pZahl << endl;

/* Ausgabe des Wertes, auf den der Zeiger zeigt.

Der Zeiger wird also dereferenziert.*/

cout << „Der Zeiger zeigt auf die Zahl “ << *pZahl << endl;

cout << „Der Zeiger zeigt auf die Speicheradresse “ << pZahl << endl;

// Die Zahl, auf die der Zeiger zeigt, wird verändert.

*pZahl = 6;

cout << „Die Zahl lautet: “ << zahl << endl;

cout << „Der Zeiger zeigt auf die Zahl “ << *pZahl << endl;

getch();

}

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.