Vorherige Seite	Eine Ebene hoch	Nächste Seite

5.2.1 Einfache Zeiger

5.2.1.1 Prinzip von einfachen Zeigern

Das Prinzip der Zeiger soll anhand eines Programmstücks erläutert werden. Achten Sie vor allem auf die Verwendung der unären Operatoren '*' und '&'.

int a=4, b;    /* zwei int-Variablen */
int z[8];      /* eine Kette von acht int-Variablen */
int *pi;       /* ein Zeiger auf int */

pi = &a;       /* jetzt zeigt pi auf a */
b = *pi;       /* jetzt hat b den Wert 4 */
*pi = 7;       /* jetzt hat a den Wert 7 */
pi = &z[2];    /* nun zeigt pi auf das dritte Element von z */
*pi = 9;       /* jetzt hat z[2] den Wert 9 */
pi++;          /* ... und jetzt zeigt pi auf z[3] */

Der Operator '&' erwartet als Argument eine Variable, und liefert als Ergebnis die Speicheradresse der Variable. Man spricht von einem Zeiger auf die Variable. Der Ausdruck &a liefert als Ergebnis einen Zeiger auf die Variable a.

Der unäre Operator '*' ist das Gegenstück zu '&'. Er erwartet als Argument einen Zeiger, und liefert als Ergebnis die Stelle, auf die der Zeiger zeigt. Dabei muss immer bekannt sein, auf welchen Datentyp der Zeiger zeigt. Handelt es sich um einen Zeiger auf int, so ist das Ergebnis des Operators '*' vom Typ int. Das heißt, die Speicherstelle, auf die der Zeiger zeigt, wird als int interpretiert. In dem Beispiel wird in der Zeile b = *pi; die Stelle, auf die der Zeiger pi zeigt, als ein int bewertet und der Inhalt der Variable b zugewiesen.

In den ersten beiden Zeilen werden auf bekannte Weise einige Variablen vom Typ int definiert. Die Definition in der dritten Zeile, int *pi; muss als Muster interpretiert werden: Der Ausdruck *pi ergibt den Typ int. Das heißt, wenn auf die Variable pi der Operator '*' angewendet wird, muss der Typ int herauskommen. Das ist nur der Fall, wenn pi ein Zeiger auf int ist.

In der vierten Programmzeile, pi = &a; wird dem Zeiger pi die Adresse von a zugewiesen. Damit ist pi ein Zeiger auf a geworden. Beachte, es wird nicht der Inhalt der Variable a übergeben, sondern die Adresse, an der die Variable steht. Ab jetzt ist der Ausdruck *pi gleich der Variable a.

Mit der Zeile b = *pi; wird nun der Inhalt, auf den der Zeiger pi zeigt (das ist in diesem Fall der Inhalt der Variable a) in die Variable b kopiert. Das Gleiche kann auch andersherum geschehen. In der Zeile *pi = 7; wird der Stelle, auf den der Zeiger pi zeigt (das ist im Beispiel immer noch die Variable a) der Wert 7 zugewiesen.

Man kann einen Zeiger auch auf ein beliebiges Element eines Vektors zeigen lassen. Die Zeile pi = &z[2]; bewirkt, dass der Zeiger pi nun auf das dritte Element des Vektors z zeigt. Wichtig: In dieser Anweisung wird nun wieder eine Adresse übergeben, und nicht der Inhalt einer Speicherstelle. (Hinweis: In der Praxis würde man pi = z+2; schreiben. Erläuterungen dazu folgen im Abschnitt 5.3.1.)

Die Anweisung *pi = 9; weist der Stelle, auf den der Zeiger pi zeigt den Wert 9 zu. In unserem Beispiel hat das den Effekt, dass das dritte Element des Vektors z, also z[2] diesen Wert 9 zugewiesen bekommt.

In der letzten Zeile, pi++; wird nun der Zeiger pi erhöht. Von den ganzzahligen Variablen wissen wir, dass der Operator ++ eine Variable um eins erhöht. Wird dieser Operator auf einen Zeiger angewandt, so wird die in ihm abgelegte Adresse um die Größe des Typs, auf den der Zeiger zeigt, erhöht. Wenn wir davon ausgehen, das in unserem Beispiel die int-Variablen vier Byte groß sind, dann wird der Zeiger pi in dem Ausdruck pi++; um vier Speicherstellen erhöht. Da der Zeiger in unserem Beispiel vorher auf das dritte Element des Vektors z gezeigt hat, zeigt er nun auf das vierte Element dieses Vektors.

5.2.1.2 Beispiel: Implementierung der Funktion strlen

Betrachten Sie nun folgende Funktion, welche die Anzahl von Zeichen in einer Zeichenkette ermittelt. Erinnern Sie sich, am Ende einer Zeichenkette steht immer eine 0.

int strlen(char* Text)
{
    char *pc=Text;
    while(*pc != '\0') pc++;
    return pc-Text;
}

Die Funktion erhält als Parameter einen Zeiger auf eine Zeichenkette, die mit einer null abgeschlossen wird. Die lokale Variable pc ist ein Zeiger auf einen Typ char und erhält den gleichen Wert wie der übergebene Zeiger Text. Das heißt, der übergebene Parameter Text und die lokale Variable pc zeigen nun beide auf die Zeichenkette, deren Länge ermittelt werden soll. In der while-Schleife wird nun geprüft, ob der Zeiger pc auf das Zeichen '\0' zeigt. Ist das nicht der Fall, wird der Zeiger um eins erhöht, das heißt die Variable pc zeigt nun auf das nächste Zeichen der Zeichenkette. Die Prüfung und die Erhöhung des Zeigers pc wird nun solange wiederholt, bis das Ende der Zeichenkette gefunden wurde.

Nach dem Durchlaufen der while-Schleife zeigt die Variable pc auf die null am Ende der Zeichenkette, während der Parameter Text immer noch auf den Anfang zeigt. Die Differenz zwischen den Zeigern ist nun die Länge der Zeichenkette. (Die null am Ende der Zeichenkette wird nicht mitgezählt.)

Die Funktion strlen ist eines der Standardbefehle von C und kann in der Headerdatei <string.h> gefunden werden.