Adressoperator

Die Adresse einer Variablen kann vom Programmierer zwar nicht bestimmt, aber über den unären Adressoperator & ermittelt werden. Die Adresse eines Datenobjektes ist über die gesamte Laufzeit des Programms unveränderlich. Der Adressoperator kann auf alle Datenobjekte mit Ausnahme von Bitfeldern und Datenobjekten der Speicherklasse register angewendet werden.

int variable = 0;                 /* Definition einer Variable vom Typ int und Initialisierung */
int *zeiger = &variable;          /* Definition einer Zeigervariablen und Initialisierung */
printf("%p", (void*)&variable);   /* gibt Adresse der Variablen in einer implementierungsabhängigen Darstellung aus, z. B. als Hexadezimalzahl */

Inhaltsoperator

Hat man eine Adresse zur Verfügung, kann man mithilfe des Inhaltsoperators * auf den Wert, der an dieser Adresse gespeichert ist, zugreifen. Der Stern in der Definition eines Zeigers * ist nicht der Inhaltsoperator *, es wird also dasselbe Symbol für unterschiedliche Zwecke verwendet. Bei der Verwendung des Inhaltsoperators auf einen Zeiger spricht man auch von der Dereferenzierung des Zeigers.

int variable = 3;
int *zeiger = &variable;        /* hier handelt es sich nicht um den Inhaltsoperator */
printf("%d", *&variable);       /* gibt den Wert „3“ aus */
printf("%d", *zeiger);          /* gibt den Wert „3“ aus */

* zeiger = 5;
printf("%d", *zeiger);          /* gibt den Wert „5“ aus */
* zeiger = *zeiger + 1;
printf("%d", *zeiger);          /* gibt den Wert „6“ aus */

Nullzeiger

Soll ein Zeiger auf kein Objekt zeigen, kann man ihm den Wert NULL zuweisen. Der Zeiger ist damit ungültig und kann solange ihm keine gültige Adresse zugewiesen wird, auch nicht sinnvoll genutzt werden, eine Dereferenzierung führt meistens zu einem Laufzeitfehler nebst Programmabbruch. Sinnvoll hingegen ist der Vergleich von (Daten)Objektzeigern mit NULL, was auch die Hauptanwendung ist.

int *zeiger;
zeiger = NULL;

* zeiger = 0;  /* Fehler */

zeiger = malloc( sizeof(*zeiger) );
if( zeiger == NULL )
  puts("Fehler bei Speicherreservierung");

NULL ist ein Macro und wird in mehreren Header-Dateien definiert (mindestens in stddef.h). Die Definition ist vom Standard implementierungsabhängig vorgegeben und vom Compilerhersteller passend implementiert, z. B.

#define NULL 0
#define NULL 0L
#define NULL (void *) 0

Zeiger erhöhen und vermindern

Zeiger können nur mithilfe der Rechenoperationen Addition einer Ganzzahl und Subtraktion einer Ganzzahl verändert werden. Bei der Addition einer Ganzzahl wird die vom Zeiger gespeicherte Adresse entsprechend erhöht, bei der Subtraktion vermindert.

char zeichen;
char *zeiger = &zeichen;
printf("%p\n", zeiger);   /* gibt z. B. die Adresse „0019FF01“ aus */
zeiger = zeiger + 1;
printf("%p\n", zeiger);   /* gibt dann die Adresse „0019FF02“ aus */

Die Summe einer in einem Zeiger gespeicherten Adresse und einer Ganzzahl ergibt in C allerdings nur bei einem Zeiger auf einen Character die um die Ganzzahl erhöhte Adresse. Vor der Addition wird die Ganzzahl nämlich noch mit der Speichergröße des Datentyps multipliziert, auf den der Zeiger verweist. Wenn ein Integer vier Bytes benötigt, ergibt die Addition einer Adresse, die auf einen Integer zeigt, mit der Ganzzahl Eins, die um vier Ganzzahlen höhere Adresse. Mit der Addition und Subtraktion auf Zeigern kann also bequem um ein oder mehr Werte nach vorn bzw. hinten gesprungen werden.

int zahl;
int *zeiger = &zahl;
printf("%p\n", zeiger); /* gibt z. B. die Adresse „0019FF01“ aus */
zeiger = zeiger + 2;
printf("%p\n", zeiger); /* gibt dann „0019FF09“ aus, also 0019FF01 plus 4 mal 2 */

Addition und Subtraktion können wie in C allgemein üblich auch hier verkürzt angeschrieben werden.

zeiger += 5;
zeiger++;

Vergleiche von Zeigern

Um Zeiger zu vergleichen, können die Vergleichsoperationen <, >, <=, >=, == und != verwendet werden.

Die Größer-/Kleiner-Vergleiche sind jedoch nur für Elemente des gleichen Arrays definiert. Für verschiedene Objekte, die nicht Elemente des gleichen Arrays sind, ist das Ergebnis "undefined behavior".

Differenz von Zeigern

Um zu ermitteln, wie viele Elemente zwei Zeiger auseinanderliegen, steht der in der Header-Datei stddef.h definierte primitive Datentyp ptrdiff_t zur Verfügung. Er wird verwendet, um das Ergebnis einer Subtraktion von zwei Zeigern zu speichern, deren Ergebnis gleichbedeutend mit der Entfernung der beiden Zeiger ist.

int array[] = {10,20,30,40};
int* zeiger = &array;
int* zeiger2 = array + 2;
ptrdiff_t differenz = zeiger2 - zeiger;
printf("%d\n", differenz);     // gibt die Entfernung der Elemente an, hier „2“ */

Auch diese Operation ist nur für Elemente des gleichen Arrays definiert.

Verwaltung von dynamischem Speicher

Dynamischer Speicher findet in C im Gegensatz zu automatischem oder statischem Speicher Verwendung in Situationen, in denen erst zur Laufzeit die erforderliche Größe bekannt ist oder die gewünschte Größe die Grenzen des automatischen/statischen Speichers im Prozess überschreitet. Um während der Laufzeit dynamischen Speicher für das Programm anzufordern, muss in C die Funktion malloc (oder die zu ihr ähnliche Funktionen calloc, realloc) verwendet werden. malloc reserviert den benötigten Speicher und liefert einen Zeiger auf diesen zurück. Ebenso muss in C die Freigabe dieses Speichers nach Gebrauch manuell mit der Funktion free erfolgen.

Um in C mit dynamischem Speicher zu arbeiten, ist es also unumgänglich, auch mit Zeigern zu arbeiten.

int *zeiger = malloc(sizeof(int));  /* Zeiger auf den Beginn eines zur Laufzeit reservierten Speicherbereiches, hier Speicher für genau einen int-Wert */

... Verwendung von zeiger ...
zeiger[0] = 1;
printf("%d", zeiger[0]);
* zeiger = 2;
printf("%d", *zeiger);

free(zeiger);    /* Freigeben des Speichers */

... nach free() bedeutet die Verwendung von zeiger undefiniertes Verhalten (UB) ...

Beim Freigeben von dynamischem Speicher mit free() ist darauf zu achten, dass der Zeigerwert (d. h. die gespeicherte Adresse) exakt die gleiche ist wie zum Zeitpunkt von malloc und dass free nur genau einmal mit dieser Adresse aufgerufen wird:

int *zeiger = malloc( 10 * sizeof(int));

... Verwendung von zeiger ...
for( int i=0; i<10; i++ )  zeiger[i] = i;
for( int i=0; i<10; i++ )  printf("%d", zeiger[i]);

free(zeiger);    /* Freigeben des Speichers */
free(zeiger);    /* Fehler! */

int *zeiger = malloc( 10 * sizeof(int));

zeiger++;

free(zeiger);    /* Fehler! */

Zeiger als Funktionsparameter

Für Funktionsparameter, die nicht als Zeiger übergeben werden (call by value), wird innerhalb der Funktion eine Kopie erzeugt. Ist eine Kopie nicht nötig oder unerwünscht, ist es auch möglich, Zeiger auf Datenobjekte an Funktionen zu übergeben (call by reference). Ein weiterer wichtiger Grund für die Übergabe von Zeigern an Funktionen ist der eingeschränkte Gültigkeitsbereich von Variablen. Es ist nur dann möglich, innerhalb von Funktionen Variablen aufrufender Programmblöcke zu verändern, wenn diese entweder global sind (was meist unerwünscht ist) oder der Funktion Zeiger auf diese Variablen übergeben werden.

void funktion(int *zeiger) {
    *zeiger = 1;              /* der Wert an der übergebenen Adresse wird mit „1“  überschrieben */
}
main() {
    int ganzzahl = 0;
    funktion(&ganzzahl);      /* als Argument wird eine Adresse übergeben */
    printf("%d\n", ganzzahl); /* gibt „1“ aus */
}

Die Parameterübergabe mithilfe von Zeigern ist auch die einzige Möglichkeit, um auch Funktionen als Argumente an andere Funktionen übergeben zu können.

Zeiger als Rückgabewert einer Funktion

Viele Funktionen der Standard-Bibliothek geben einen Zeiger als Rückgabewert zurück. Der zurückgegebene Zeiger ist dabei immer ein Zeiger auf die Anfangsadresse des Rückgabetyps. Anwendung findet diese Methode in C vor allem zur Übergabe von Zeichenketten und Strukturen.

int *funktion(void) {
    static int zahl = 3;
    int *zeiger = &zahl;
    return zeiger;           /* hier wird ein Zeiger zurückgegeben */
}
main() {
    int *zeiger;
    zeiger = funktion();
    printf("%d\n", *zeiger); /* gibt „3“ aus */
}

Datenstrukturen

Siehe den Artikel Verbund (Datentyp).

Rekursive Datenstrukturen

Rekursive Datenstrukturen wie Listen oder Bäume sind kaum ohne Zeiger implementierbar.

Verarbeitung von Datenobjekten beliebigen Typs

Mithilfe des typenlosen void-Zeigers lassen sich Datenobjekte beliebigen Typs verarbeiten.