8.7 Zeiger

Ein Zeiger oder Pointer ist die Adresse einer Variablen. Bisher hat der Compiler bei Variablen selbst entschieden, wo der Platz im Speicher liegt. Mit dem Namen der Variablen hat man den Wert bekommen. Mit einem Pointer speichert man die Adresse, wo der Wert zu finden ist. Wie ird nun ein Zeiger deklariert? Dazu wird bei einer Deklaration vor den Namen der Variablen ein * gesetzt und anstelle einer Variablen eines bestimmten Datentyps hat man einen Zeiger auf diesen Typ deklariert.

...
int i,*ptri;

Dieses kleine Beispiel deklariert eine Variable vom Typ int mit dem Namen i und einen Zeiger auf einen int mit dem Namen ptri. Um auf den Wert, auf den der Zeiger zeigt, zuzugreifen, muß der Zeiger dereferenziert werden. Dazu schreibt man wiederum einen * vor die Variable, wenn man sie in einem Ausdruck benutzt.

...
i = *ptri;

Nur, wo liegt denn jetzt eigentlich der Speicher, auf den unser Pointer zeigt? Hierfür ist der Programmierer selbst verantwortlich! Hieraus ergibt sich die Mächtigkeit, aber auch die Fehlerträchtigkeit von Pointern. Deshalb werden wir uns auch genug Zeit lassen und mit Hilfe von Beispielen die Arbeit mit Pointern und das Verhalten anschaulich darstellen.

Eine Möglichkeit ist es, sich die Adresse einer Variablen mit dem Adreßoperator & geben zu lassen. Dazu folgt ein kleines Beispielprogramm:

#include <stdio.h>

int main(void)
{
   int i,j,p;

   i = 3
   p = &i;
   j = *p;
   printf("i = %d, j = %d\n",i,j);
}

Dieses Beispiel setzt i auf den Wert 3. Dann wird p auf den Wert der Adresse von i gesetzt. Anschließend wird der Wert, auf den p zeigt, j zugewiesen. Danach hat j den Wert 3, denn der Wert, auf den p zeigt ist natürlich i.

Damit das noch anschaulicher wird, malen wir uns einfach mal einen möglichen Speicher auf und tragen die entsprechenden Werte ein:

+-----+-----+-----+-----+-----+
I     I     I     I     I     I
+-----+-----+-----+-----+-----+
   0     1     2     3     4

Der Compiler legt jetzt in diesen einfachen Speicher unsere 3 Variablen an. Wir machen es uns jetzt einfach und ordnen jede Variable einer Zelle zu:

+-----+-----+-----+-----+-----+
|     |     |     |     |     |
+-----+-----+-----+-----+-----+
   0     1     2     3     4
   i     j     p

Jetzt schreiben wir den Wert 3 in die Variable i:

+-----+-----+-----+-----+-----+
|  3  |     |     |     |     |
+-----+-----+-----+-----+-----+
   0     1     2     3     4
   i     j     p

Nun wird in die Variable p die Adresse von i geschrieben. Wir sehen, daß i in der Zelle 0 bgespeichert ist. Also hat p den Wert 0:

+-----+-----+-----+-----+-----+
|  3  |     |  0  |     |     |
+-----+-----+-----+-----+-----+
   0     1     2     3     4
   i     j     p

Nun schreiben wir den Wert, auf den p zeigt, in die Variable j. Wir sehen, daß p auf die Adresse 0 zeigt, also die Adresse von i. Und was dort steht, wird j zugewiesen. Auf der Adresse 0 steht 3, wir haben ja die 3 der Variablen i zugewiesen. Damit bekommen wir:

+-----+-----+-----+-----+-----+
|  3  |  3  |  0  |     |     |
+-----+-----+-----+-----+-----+
   0     1     2     3     4
   i     j     p

In vielen Beispielen wird durch Pfeile gezeigt, auf welche Variable ein Pointer zeigt. Das könnte dann folgendermaßen in unser Beispiel integriert werden:

+-----+-----+-----+-----+-----+
|  3  |  3  |  0  |     |     |
+-----+-----+-----+-----+-----+
   0     1     2     3     4
   i <+  j     p
      |        |
      +--------+

Eine weitere Möglichkeit, den Speicher für einen Zeiger zu verwalten, ist die Verwendung der Funktionen malloc, free, ... um sich damit einen Speicherbereich zuweisen zu lassen. Beispiele hierzu folgen später.

• 8.7.1 Zeiger und Felder
• 8.7.2 Zeiger und Strukturen
• 8.7.3 Zeiger auf Zeiger

English version not yet available.