Der Zeiger und die Adresse

Zeiger sind ganz besondere Variablen. Ihr Inhalt ist eigentlich nebensächlich. Viel interessanter ist, dass sie auf andere Variablen zeigen können. Sie betrachten also nicht die Zeigervariable selbst, sondern über die Zeigervariable auf den Inhalt einer anderen Variablen. Diese Indirektion ist zu Anfang nicht ganz leicht zu verstehen und auch später durchaus Anlass zur Verwirrung.

Das moderne Parkhaus

Magnetkarte als Zeiger

Info-Terminal

Variablen und Zeiger

Zeigervariable

Definition

char *charZeiger;

Die Variable charZeiger ist also ein Zeiger auf eine Variable vom Typ char. Anders ausgedrückt, kann in der Variablen charZeiger die Position der Speicherstelle abgestellt werden, an der sich eine char-Variable befindet.

Adresse

char Buchstabe = 'A';
charZeiger = &Buchstabe;

Zugriff über den Zeiger

cout << *charZeiger;

*charZeiger = 'B';
cout << Buchstabe;

Durch den Stern vor der Zeigervariablen wird deutlich gemacht, dass wir nicht auf den Inhalt der Zeigervariablen zugreifen, sondern auf den Speicherplatz, auf den der Zeiger zeigt. Da charZeiger immer noch die Adresse der Variablen Buchstabe enthält, wird deren Inhalt nun verändert. Wenn die Variable Buchstabe ausgegeben wird, erscheint auf dem Bildschirm jetzt ein 'B'.

Im Buch steht hier die Grafik (abbzeiger)

Die Abbildung zeigt die Situation nach der Zuweisung des 'B' über den Zeiger charZeiger. Oben rechts befindet sich die Variable Buchstabe. Es wird hier einfach davon ausgegangen, dass sie an der Speicherstelle 17543 angelegt wurde. Genau diese Nummer enthält die Zeigervariable charZeiger, die ihrerseits an der Stelle 23164 im Speicher liegt. Auch das Größenverhältnis ist durchaus passend. Während eine Variable vom Typ char meist ein Byte belegt, benötigt eine Zeigervariable auf einem normalen PC vier Byte.

Wozu?

• Sie können ein Programmstück schreiben, das über einen Zeiger auf eine Variable zugreift. Sobald Sie den Zeiger auf die Adresse einer anderen Variablen >>umbiegen<<, arbeitet das gleiche Programmstück mit einer anderen Variablen. Sie werden dies noch im Zusammenhang mit Funktionsparametern kennenlernen.
• Sie können im Laufe des Programms neuen Speicher anfordern. Wie Sie später sehen werden, wird dazu der Befehl new verwendet. Damit das Programm auf den neuen Speicher zugreifen kann, liefert new einen Zeiger darauf.
• Sie können mit Hilfe von Zeigern komplexe Datenkonstrukte nachbilden. Dazu bilden Sie Variablenverbunde aus Daten und Zeigern. Zeigt der Zeiger eines Variablenverbundes auf den nächsten, lassen sich daraus Ketten bilden, die man als lineare Liste bezeichnet. Wenn Sie in den Datenverbund mehrere Zeiger anhängen, können Sie ein baumartiges Gebilde erzeugen.

Selbstschutz

char *charZeiger;  // charZeiger definieren
charZeiger=0;      // als Nullzeiger sichern

Soll die Variable mit 0 initialisiert werden, können Sie wie bei einer Integer-Variablen einfach =0 anhängen. In C-Programmen finden Sie in diesem Zusammenhang oft eine Konstante namens NULL. Dabei handelt es sich um eine 0, die explizit für die Verwendung mit Zeigern deklariert ist. In C++ ist NULL weder erforderlich noch sinnvoll.

char *charZeiger = 0;

Indirekter Zugriff

char *charZeiger;         // Definition der Zeigervariable
charZeiger = 0;           // Sichern als Nullzeiger
char Buchstabe = 'A';     // Variable soll später das Ziel sein
charZeiger = &Buchstabe;  // Adresse von Buchstabe zuweisen
*charZeiger = 'B';        // Buchstabe enthält nun 'B'

Indirektionsoperator

int main()
{
    int *intZeiger = 0;
    int intVar = 5;

    intZeiger = &intVar;
    // der Zeiger bekommt die Adresse von intVar
    // dann zeigt intZeiger auf intVar
    *intZeiger = 1;
    // die Variable, auf die intZeiger zeigt, wird
    // mit dem Wert 1 belegt. Damit ist nun der
    // Inhalt von intVar 1.
    intVar = *intZeiger + 1;
    // intVar berechnet sich aus 1 und dem Wert, auf den
    // intZeiger zeigt. Das ist aber intVar selbst.
    // Darum ist intVar anschließend 2.
}

Im Beispiel wurde die Zeigervariable wie empfohlen bereits bei ihrer Definition auf 0 gesetzt. Wenn die Zeigervariable lokal ist, kann sie ohne Initialisierung einen beliebigen Wert enthalten. Das bedeutet, sie zeigt auf eine zufällige Position im Hauptspeicher. Wird nun aus Versehen über diesen Zeiger zugegriffen, bevor er korrekt belegt wurde, greift das Programm irgendwo in den Speicher. So werden unsinnige Daten ermittelt oder gar Daten geändert, ohne dass es sofort zu einem Fehler kommt. Das Programm läuft mit defekten Daten weiter und wird erst viel später einen Fehler liefern, dessen Ursprung dann aber nur schwer erkennbar ist. Wurde der Zeiger dagegen auf 0 gesetzt, wird der erste Zugriff über ihn zum Absturz des Programms führen. Mit Hilfe eines Debuggers können Sie dann leicht feststellen, wo dieser Absturz passiert. Sie können auch sofort sehen, dass der Zeiger auf 0 steht, und werden sicher schnell erkennen, wo Sie vergessen haben, den Zeiger korrekt zu setzen.

Arrays und Zeiger

Verwandtschaft

int Zahlen[4];
int *ZahlZeiger = 0;
ZahlZeiger = Zahlen;

ZahlZeiger = Zahlen;
ZahlZeiger[3] = 4;

Diese Situation wird in der Abbildung (abbarrayptr) dargestellt. Nicht ohne Grund wird auch die Arrayvariable Zahlen als Zeiger dargestellt.

An dieser Stelle befindet sich im Buch die Abbildung (abbarrayptr).

Die folgenden Konstruktionen werden Ihnen vielleicht den Angstschweiß auf die Stirn treiben; Ihrem Compiler wird es nicht einmal merkwürdig erscheinen. Die Ausgangssituation scheint zunächst ähnlich:

int Zahlen[4];
int *ZahlZeiger = 0;

ZahlZeiger = Zahlen;
ZahlZeiger[3] = 5;
ZahlZeiger = &Zahlen[2];
ZahlZeiger[1] = 3; // landet in Zahlen[3]!

Die Zeile, in der der Zeiger auf die Adresse des dritten Array-Elements gesetzt wird, ist besonders originell:

ZahlZeiger = &Zahlen[2];

Im Buch befindet sich hier die Abbildung (abbarrayptr2).

Durch die Verschiebung wird ZahlZeiger[0] identisch zu Zahlen[2]. Daraus resultiert, dass ZahlZeiger[1] das letzte Element des Arrays Zahlen ist. Würde also das Element ZahlZeiger[2] verarbeitet, würde auf einen Speicherbereich zugegriffen werden, der außerhalb des reservierten Raums steht. Die Ergebnisse sind unvorhersehbar.

Der entscheidende Unterschied: Bei der Definition eines Arrays wird der
Speicher für die Array-Elemente reserviert. Bei der Definition eines Zeigers
wird nur Speicher für den Zeiger selbst angelegt.

Zeigerarithmetik

Beispiel

int wert[MAX];

  for(i=0; i<MAX; i++)
  {
      wert[i] = 0;
  }

Alternativ können Sie einen Zeiger verwenden und ihn durch das Array laufen lassen:

int wert[MAX];
int *lauf = wert;

for(i=0; i<MAX; i++)
{
    *lauf = 0;
    lauf++;
}

Effizienz

An dieser Stelle befindet sich im Buch die Abbildung (abbzeigerarith)

for-Schleife

char Quelle[MAX];
for (char *p = Quelle; *p; p++)
{
    cout << *p ;
}

Addition und Subtraktion

*(Zeiger+2) = 4;
Zeiger[2] = 4;

Konstante Zeiger

const int *konstantesZiel = &ZielVariable;

int * const konstanterZeiger = &ZielVariable;

const int * const komplettKonstant = &ZielVariable;

void *ptr;

void *voidPtr;
int  *intPtr;
voidPtr = intPtr;         // funktioniert problemlos
intPtr  = (int *)voidPtr; // explizites Casting notwendig