Pointer – Einführung
Du möchtest wissen, was ein Pointer ist und wie er in C funktioniert? Hier zeigen wir dir alles, was du zum Thema Pointer wissen musst.
Inhaltsübersicht
Was sind Zeiger bzw. Pointer in C?
Ein Pointer oder im Deutschen eben auch Zeiger, ist eigentlich nichts anderes als das, was der Name bereits beschreibt. Pointer zeigen nämlich auf eine Adresse im Speicher, die du selbst bestimmen kannst. Somit kannst du sie dir wie Variablen vorstellen, die statt einer Zahl oder eines Buchstaben eine Speicheradresse als Wert erhalten.
Diese Adresse wiederum speichert dann einen, vom Typen des Pointers abhängigen, Wert. Das heißt also: Wenn du einen Zeiger des Typs int erstellst, speichert dieser die Adresse eines Speicherbereichs, in dem eine int-Variable abgelegt ist. Dasselbe gilt für andere Datentypen.
Globale und lokale Zeiger deklarieren
Aber wie deklarieren wir überhaupt einen Zeiger? Wenn wir eine int-Variable x haben und einen Pointer p, der auf x zeigen soll, dann schreiben wir einfach:
int * p = x;
X nennen wir dabei die Bezugsvariable zu p. Genauso wie bei Variablen können wir Pointer sowohl global, als auch lokal definieren. Globale Zeiger werden außerhalb der Funktionen deklariert und zeigen standardmäßig nirgendwo hin. Erst mit der Wertanweisung ersetzen wir die symbolische Konstante NULL, die statt eines Wertes gespeichert wird.
Wollen wir unseren Pointer nun aber lokal deklarieren, wird er, genau wie lokale Variablen auch, in einem bestimmten Gültigkeitsbereich deklariert und zeigt dementsprechend auch irgendwo hin. Wo dieses ‚Irgendwo‘ liegt, können wir selbst mit einer Wertanweisung festlegen.
Doppelzeiger und konstante Zeiger
Wir wissen nun also, wie wir einen Pointer initialisieren und wie man Variablen als Wert angibt, aber was, wenn wir mit einem Zeiger auf einen weiteren Pointer zeigen? Das dann entstehende Gebilde nennt man Doppelzeiger, denn dabei entsteht eine Kette von Zeigern, an deren Ende sich eine Variable befindet. Sowohl zugewiesene Variablen, als auch andere Pointer müssen vom selben Typ sein, damit dein Programm funktioniert.
Wenn wir uns jetzt weiter an den Variablen orientieren, sehen wir auch, dass es passend zu konstanten Variablen auch konstante Zeiger gibt. Diese deklarieren wir mit:
int * const p; oder const int * p;
Zeiger dieser Art können nicht umgebogen werden. Das heißt, ihnen kann nicht mittels einer solchen Anweisung p = e; ein neuer Wert zugewiesen werden. *p kann also nicht geändert werden.
Rein praktisch macht es kaum einen Unterschied, ob du einen konstanten Zeiger auf die erste oder die zweite Weise initialisierst, allerdings handelt es sich bei der ersten Möglichkeit um einen ‚andere Art‘ von Zeiger, als bei letzterer.
Die erste Variable nennt man einen konstanten Pointer auf int, die zweite einen Zeiger auf einen konstanten Wert.
Verwendung von Pointern als Funktionsparametern
Last but not least sollten wir noch klären, wie man Pointer als Funktionsparameter benutzen kann.
int function (int * p) {}
Wie du siehst, kannst du auch hier dasselbe wie mit einer Variable machen, aber das Besondere ist, dass wir auch ganze Funktionen als Pointer deklarieren können.
int * test (void) {}
Was diese Funktionen von anderen unterscheidet ist, dass sie keinen Wert zurückgeben, sondern die Adresse, an der dieser Wert gespeichert ist.
Aber warum solltest du jetzt überhaupt Pointer verwenden, wenn doch nahezu alle Vorgänge identisch zu Variablen sind? Das liegt am sogenannten „Call by Reference -Prinzip“. Dieses besagt, dass du, wenn du beim Aufruf deiner Funktion die Adresse einer Variablen übergibst, du deren Wert über Dereferenzierung mit einem Pointer direkt bearbeiten kannst.
Hier ist a vor Funktionsaufruf 5 und nach Funktionsaufruf 6 und das, obwohl der Variablen-Wert nicht zurückgegeben wurde.