Zeiger und Speicheradressen in C

Du kannst dir Speicher als Folge nummerierter Bytes vorstellen. Jede Nummer ist eine Adresse. Ein Objekt wie ein int belegt aufeinanderfolgende Bytes, und seine Adresse bezeichnet sein erstes Byte. Der Name im Quellcode ermöglicht dem Compiler, dieses Objekt zu finden; die Sprache verlangt nicht, dass neben dem Wert eine Namenskennzeichnung gespeichert wird.

Speicher mit sizeof messen

sizeof gibt die Größe in Bytes als Wert vom Typ size_t an. Verwende %zu zur Ausgabe:

int scores[4] = {12, 18, 15, 21};
printf("%zu %zu\n", sizeof scores, sizeof scores[0]);

Bei int mit 4 Byte gibt dies 16 4 aus. Das erste Ergebnis misst alle vier Elemente, das zweite eines. sizeof(char) ist immer 1. Eine verbreitete Anordnung auf 64-Bit-Desktops verwendet int mit 4 Byte, double mit 8 Byte und Objektzeiger mit 8 Byte. Andere Zielsysteme können abweichen. Selbst unter 64-Bit-Systemen belegt long unter Linux und macOS häufig 8 Byte, unter Windows aber 4.

Speichergröße und Textlänge beantworten unterschiedliche Fragen. Bei char word[20] = "hi"; ist sizeof word gleich 20, während strlen(word) gleich 2 ist. Das Array enthält weiterhin 20 Elemente, obwohl seine Zeichenkette nur zwei Buchstaben und ein abschließendes Nullzeichen verwendet. Außer bei Arrays variabler Länge stehen diese Objektgrößen zur Kompilierzeit fest.

Die Adressen eines Arrays verfolgen

Hexadezimaladressen verwenden die Ziffern 0 bis 9, danach a bis f. Das Präfix 0x kennzeichnet die Basis 16. Bei einem Beispielarray, das bei 0x1000 beginnt, beginnen vier Elemente mit je 4 Byte hier:

0x100C ist dezimal 4.108 und liegt zwölf Byte hinter 0x1000. Zwischen Arrayelementen gibt es keine Lücken. Für getrennt deklarierte Variablen sind weder Reihenfolge noch Abstand garantiert; tatsächlich ausgegebene Adressen können sich auch zwischen Programmläufen ändern. Ein Compiler kann einen Wert in einem Prozessorregister halten, wenn kein adressierbarer Speicher benötigt wird.

Speicherausrichtung und Byte-Reihenfolge

Die Speicherausrichtung schränkt ein, wo Objekte eines Typs beginnen dürfen. Bei einer verbreiteten Anordnung liegen int mit 4 Byte auf Vielfachen von 4 und double mit 8 Byte auf Vielfachen von 8. Der Compiler sorgt bei deklarierten Objekten für eine geeignete Speicherausrichtung.

Die Byte-Reihenfolge ist die Reihenfolge der Bytes innerhalb eines Werts aus mehreren Bytes. Bei einem unsigned int mit 4 Byte, der 0x12345678 enthält, stehen bei Little-Endian-Speicherung die Bytes 78 56 34 12 in aufsteigender Adressreihenfolge; bei Big-Endian-Speicherung sind es 12 34 56 78. Ein unsigned char * kann die Repräsentation eines Objekts byteweise untersuchen. Die Byte-Reihenfolge ändert nicht die Indexreihenfolge des Arrays.

Das Objekt am Leben halten

Eine gewöhnliche lokale Variable hat automatische Speicherdauer: Ihre Lebensdauer erstreckt sich über die Ausführung ihres Blocks. Typische Implementierungen halten solche Objekte im Stackframe eines Aufrufs und verwenden diesen Speicher anschließend wieder. Globale Variablen, static-Variablen und Zeichenkettenliterale existieren während des gesamten Programms. Das Speichern einer Adresse verlängert die Lebensdauer ihres Objekts nicht.

Ein Zeiger speichert eine Adresse und hat einen Typ, der das Objekt beschreibt, auf das er zugreifen kann. Die Deklaration eines int * stellt Speicher für einen Zeiger bereit; sie erstellt keinen int zur Verwendung durch diesen Zeiger. Gib dem Zeiger bei seiner Deklaration einen bekannten Wert.

Die Adresse eines Objekts ermitteln

int count = 42;
int *p = &count;

Der unäre Adressoperator & ermittelt die Adresse von count. Beginnt count bei der Beispieladresse 0x1000, enthält p den Wert 0x1000, während count den Wert 42 enthält. Der Zeiger ist ebenfalls ein Objekt: &p ist die Adresse des separaten Speicherbereichs, der diesen Zeiger enthält.

Du kannst die Adresse eines Arrayelements ermitteln, etwa mit &scores[2]. Eine numerische Konstante oder ein Berechnungsergebnis ist kein gespeichertes Objekt, das du auf diese Weise adressieren kannst: &42 und &(count + 1) sind ungültig. Der binäre Ausdruck a & b verwendet dasselbe Symbol für ein bitweises UND; an der Anzahl der Operanden erkennst du die jeweilige Operation.

Jeden Deklarator lesen

Leerraumzeichen ändern keinen dieser Typen. int* p und int *p sind gleichwertig. Deklarierst du pro Zeile einen Zeiger, übersiehst du sein Sternchen weniger leicht. Auf verbreiteten 64-Bit-Desktops belegt ein Objektzeiger 8 Byte, doch seine eigene Größe sagt nichts über die Größe des Objekts aus, auf das er zeigt.

Der Typ, auf den der Zeiger zeigt, ist entscheidend. Verwende für double price = 9.5; den Zeiger double *r = &price;. Die Initialisierung eines int * mit &price erzeugt eine Meldung über inkompatible Zeigertypen. Eine explizite Typumwandlung, die diese Meldung verbirgt, macht einen int-Zugriff auf diesen double nicht gültig: Der Typ bestimmt, wie auf die gespeicherten Bytes zugegriffen wird.

Einen Zeiger neu ausrichten

int a = 5, b = 8;
int *p = &a;
p = &b;

Die letzte Zuweisung ersetzt die Adresse in p. Sie verschiebt keine der beiden Ganzzahlen und kopiert auch nicht den Wert einer Ganzzahl in die andere. Nun zeigt p auf b; a ist weiterhin 5 und b weiterhin 8. Mehrere Zeigervariablen können auch dieselbe Adresse speichern.

Einen bekannten leeren Zustand verwenden

Ein nicht initialisierter lokaler Zeiger hat einen unbestimmten Wert und wird manchmal wilder Zeiger genannt. Untersuche und dereferenziere ihn nicht. Initialisiere ihn mit der Adresse eines gültigen Objekts oder mit NULL, das unter anderem über die Headerdateien <stddef.h> und <stdio.h> verfügbar ist:

int *pending = NULL;
if (pending == NULL) {
    pending = &count;
}

Ein Nullzeiger bezeichnet kein Objekt. !pending ist eine weitere Prüfung auf einen Nullzeiger. Diese Prüfungen sind nur für initialisierte Zeiger sinnvoll; sie überprüfen weder eine beliebige Adresse noch einen Zeiger, dessen Objekt nicht mehr existiert.

Einen Objektzeiger ausgeben

printf("%p\n", (void *)p);

%p erwartet void *, daher verwende bei einem typisierten Objektzeiger die explizite Typumwandlung. Die Implementierung legt die ausgegebene Darstellung fest; häufig ist sie hexadezimal. %d und %x erwarten Ganzzahlargumente bestimmter Typen und können %p nicht ersetzen.

Der unäre Dereferenzierungsoperator * folgt einem Zeiger zu seinem Objekt. Zeigt p auf x, bezeichnet *p das Objekt x selbst. Das Lesen von *p liest dieses Objekt; eine Zuweisung an *p ändert es.

Einen Schreibzugriff über eine Adresse verfolgen

int x = 10;
int *p = &x;
*p = *p + 5;
int y = *p * 2;
printf("%d %d %d\n", x, *p, y);

Zuerst speichert p die Adresse von x. Auf der rechten Seite der Zuweisung liest *p den Wert 10. Die Addition von 5 ergibt 15, und das *p auf der linken Seite speichert 15 in x. Die nächste Zeile multipliziert den aktualisierten Wert mit 2, sodass y zu 30 wird. Die Ausgabe ist 15 15 30.

Der Kontext unterscheidet die Sternchen: int *p deklariert einen Zeiger, das unäre *p greift auf ein Objekt zu, und *p * 2 enthält außerdem eine binäre Multiplikation. Für ein gültiges Objekt x bezeichnet *&x das Objekt x; für einen Zeiger auf ein gültiges Objekt liefert &*p den Zeigerwert zurück.

Adressen und Inhalte auseinanderhalten

Beginne jede Ablaufverfolgung mit zwei Angaben: welche Adresse jeder Zeiger enthält und welchen Wert jede Ganzzahl enthält. Angenommen, p zeigt auf a mit dem Wert 3 und q auf b mit dem Wert 8.

Ein Speicherdiagramm verwendet ein Kästchen für jedes Objekt. Beschrifte ein Kästchen mit Name und Adresse, trage seinen aktuellen Wert ein und zeichne einen Pfeil vom Zeiger zu seinem Ziel. Eine Adresszuweisung versetzt einen Pfeil; eine Zuweisung über einen Zeiger ändert den Inhalt eines Zielkästchens.

Nach p = q sind die Zeiger Aliase für b. Führst du anschließend *p = 20; aus, liefert das Lesen von *q oder b den Wert 20. Das Kopieren einer Adresse schafft einen weiteren Zugriffsweg auf dasselbe Objekt, keine weitere Ganzzahl.

Prüfen, ob eine Dereferenzierung gültig ist

Ein für einen Zugriff verwendeter Zeiger muss ein noch existierendes Objekt eines geeigneten Typs bezeichnen; zum Schreiben muss das Objekt außerdem veränderbar sein. Nullzeiger bezeichnen kein Objekt. Nicht initialisierte Zeiger haben kein bekanntes nutzbares Ziel. Ein Zeiger wird zum hängenden Zeiger, wenn die Lebensdauer seines Ziels endet.

Der Zugriff über einen ungültigen Zeiger ist undefiniertes Verhalten: C stellt keine Anforderungen an das Ergebnis. Das Programm kann mit einer Speicherzugriffsverletzung stoppen, Daten beschädigen oder scheinbar normal laufen. Ein scheinbar erfolgreicher Lauf kann nicht belegen, dass der Zugriff gültig war.

Prüfe einen Zeiger, der zulässigerweise ein Nullzeiger sein kann, vor dem Zugriff:

if (p != NULL) {
    *p = 0;
}

Weist du einem nicht mehr benötigten Zeiger NULL zu, kannst du eine spätere versehentliche Verwendung dieser Variablen verhindern. Andere Aliase werden dadurch nicht zurückgesetzt. Behalte die Lebensdauer des Objekts gesondert im Blick.

Den gemeinten Wert in Klammern setzen

Das Postfix-++ bindet stärker als das unäre *. Daher bedeutet *p++ dasselbe wie *(p++): Der alte Zeiger wird verwendet, um einen Wert zu erreichen, und der Zeiger wird weitergesetzt. (*p)++ erhöht den Wert, auf den der Zeiger zeigt, und lässt den Zeiger an seiner Stelle. *p + 1 liest den Wert und addiert 1, ohne das Ergebnis zu speichern. Das sind drei unterschiedliche Aktionen.

C übergibt jedes Argument als Wert. Ein Parameter ist eine lokale Variable, die aus dem Argument initialisiert wird. Die Übergabe einer Adresse ändert diese Regel nicht: Die Funktion erhält eine Kopie der Adresse, und diese Kopie kann das Objekt des Aufrufers erreichen.

Zwei Reset-Funktionen vergleichen

void reset_copy(int n) {
    n = 0;
}

void reset(int *n) {
    *n = 0;
}

Bei int score = 12; ändert reset_copy(score) nur das lokale n. score bleibt 12. Der Aufruf reset(&score) kopiert die Adresse von score in den Zeigerparameter n; die Zuweisung an *n ändert dann score zu 0. Diese Technik wird häufig Referenzübergabe genannt, obwohl die tatsächliche Argumentübergabe der Sprache weiterhin als Wert erfolgt.

Die Adresse im Aufruf und die Dereferenzierung im Funktionskörper haben unterschiedliche Aufgaben. &score teilt der Funktion mit, wo sich das Objekt befindet. *n = 0 gibt an, was dort gespeichert werden soll. Der Aufruf reset(score) liefert eine Ganzzahl, wo ein Zeiger erforderlich ist, und löst eine Compilermeldung aus.

Eine Vertauschung nachvollziehen

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}

/* Inside a calling function: */
int x = 3, y = 8;
swap(&x, &y);

1. a zeigt auf x und b auf y.
2. t speichert den ursprünglichen Wert von x, also 3.
3. *a = *b schreibt 8 in x.
4. *b = t schreibt die gespeicherte 3 in y.

Beide Variablen des Aufrufers ändern sich. Eine Version mit einfachen Parametern int a, int b vertauscht nur Kopien. Auch eine Zeigerversion mit int *t = a; a = b; b = t; vertauscht die Ganzzahlen nicht: Sie richtet nur die lokalen Zeigerparameter neu aus.

Mehr als ein Ergebnis liefern

Eine return-Anweisung liefert einen Wert, aber Zeigerparameter können zusätzliche Ausgaben übertragen:

void divide(int total, int size, int *q, int *r) {
    *q = total / size;
    *r = total % size;
}

/* size must be positive for these example inputs. */
int q, r;
divide(17, 5, &q, &r);

Die Ganzzahldivision ergibt für q den Wert 3 und für r den Wert 2. Der Aufrufer stellt zwei unterschiedliche beschreibbare Objekte bereit. Eine weitere nützliche Schnittstelle gibt einen Erfolgsstatus zurück und schreibt eine Ausgabe nur bei Erfolg; Aufrufer prüfen diesen Status, bevor sie die Ausgabe verwenden.

Dasselbe Muster in Bibliotheksaufrufen erkennen

scanf("%d", &age) benötigt die Adresse von age, weil die Funktion dort eine eingelesene Ganzzahl speichert. Die Übergabe von age liefert einen Wert statt des erforderlichen int * und führt zu undefiniertem Verhalten. Prüfe, ob scanf 1 zurückgibt, bevor du den neu gelesenen Wert verwendest.

Für Text übergibt char name[20]; scanf("%19s", name); einen Zeiger auf das erste Zeichen des Arrays. Die Breite erlaubt höchstens 19 Eingabezeichen und lässt Platz für '\0'. Der Arrayausdruck stellt den erforderlichen Zeichenzeiger bereits bereit.

Ein Arrayparameter erhält ebenfalls eine Adresse, keinen kopierten Block von Elementen. In void zero(int *a, size_t n) wirken sich Zuweisungen an a[i] auf das Array des Aufrufers aus. Bei der Übergabe der Adresse wird nur ein Zeiger kopiert. So können auch Funktionen, die nur lesen, große Arrays untersuchen, ohne jedes Element zu kopieren.

Eine Zeigerschnittstelle sollte zwei Dinge klären: ob die Funktion darüber schreiben darf und wie lange der referenzierte Speicher gültig bleibt. const beantwortet die erste Frage. Die Lebensdauer des Objekts beantwortet die zweite.

Die const-Einschränkung zuordnen

Ein Zeiger auf konstante Daten schränkt diesen Zugriffsweg ein. Wurde x als gewöhnliches int x = 5; definiert, ist x = 6; weiterhin erlaubt, auch während ein const int * darauf zeigt. Wurde das Objekt selbst mit const definiert, ist jeder Versuch, es über einen Zeiger zu ändern, undefiniertes Verhalten.

Ein konstanter Zeiger behält eine Adresse. Er muss initialisiert werden, und die Adresse kann später nicht ersetzt werden. Das Objekt an dieser Adresse kann sich weiterhin ändern, wenn sein Typ dies erlaubt. Lies vom Namen aus nach außen: int *const p macht p konstant; const int *p schützt den int, der über p erreicht wird.

Verwende einen nur lesenden Parameter wie const char *s, wenn eine Funktion eine Zeichenkette nur untersucht. Ein gewöhnlicher char * kann ohne explizite Typumwandlung an diesen Parameter übergeben werden. Die Funktion kann ihren lokalen Zeiger s weiterbewegen, aber eine Zuweisung über *s wird abgelehnt. Für die Rückumwandlung in einen beschreibbaren Typ reicht es nicht, eine Compilerwarnung zu beseitigen: Das zugrunde liegende Objekt muss tatsächlich veränderbar sein.

Eine Position im Speicher des Aufrufers zurückgeben

int *find(int *a, size_t n, int target) {
    for (size_t i = 0; i < n; i++) {
        if (a[i] == target) return &a[i];
    }
    return NULL;
}

Für int v[] = {4, 9, 2, 9}; gibt find(v, 4, 9) den Zeiger &v[1] zurück. Die Funktion endet, aber v gehört dem Aufrufer und existiert dort weiterhin. Nach der Prüfung des Ergebnisses auf NULL kann der Aufrufer found - v berechnen, um den Index 1 zu erhalten, oder mit *found = 0 das Element aktualisieren. Eine Suche nach 7 ergibt NULL, das nicht dereferenziert werden darf. strchr und strstr verwenden dieselbe Konvention eines Nullzeigers für „nicht gefunden“.

Adressen nicht mehr existierender lokaler Variablen zurückweisen

int *bad(void) {
    int result = 42;
    return &result;
}

result hat automatische Speicherdauer. Die Lebensdauer endet, wenn der Aufruf zurückkehrt, sodass der Aufrufer einen hängenden Zeiger erhält. Der Compiler kann warnen, und jeder spätere Zugriff über diesen Zeiger ist undefiniertes Verhalten. Dass die alten Bytes bei einem Lauf sichtbar sind, hält das Objekt nicht am Leben.

Dasselbe Problem kann an der schließenden Klammer eines inneren Blocks auftreten. Ein äußerer Zeiger kann die Lebensdauer einer inneren Variablen, deren Adresse er gespeichert hat, nicht verlängern.

Speicher mit ausreichender Lebensdauer wählen

Gib einen int-Wert zurück, wenn der Aufrufer nur ein ganzzahliges Ergebnis benötigt. Lass den Aufrufer für mehrere Ergebnisse Speicher zum Befüllen bereitstellen. Ein zurückgegebener Zeiger kann auch auf das Array des Aufrufers, ein über const char * zugängliches Zeichenkettenliteral oder ein static-Objekt verweisen.

Eine lokale statische Variable wird einmal initialisiert und existiert während des gesamten Programms, wird aber von allen Aufrufen gemeinsam genutzt. Speichert ein späterer Aufruf dort einen neuen Wert, sieht jeder zuvor zurückgegebene Zeiger diese Änderung. Statischer Speicher löst das Problem der Lebensdauer, ohne jedem Aufruf ein eigenes unabhängiges Ergebnisobjekt zu geben.

Die Addition einer Ganzzahl zu einem Zeiger bewegt ihn um Elemente des referenzierten Typs. Zeigt p auf das Arrayelement i, zeigt p + n auf Element i + n, sofern die entstehende Position innerhalb des Arrays oder unmittelbar hinter dessen Ende liegt.

Die Adresse einmal skalieren

Ausgehend von der Beispieladresse 0x1000 ergibt die Addition von 3 diese Ergebnisse:

Der Compiler führt die Skalierung durch. p + 3 * sizeof *p skaliert zweimal und führt im Allgemeinen zum falschen Element. Verwende unsigned char *, wenn die gewünschte Schrittweite tatsächlich ein Byte der Objektrepräsentation ist.

Für int a[6] = {10, 20, 30, 40, 50, 60}; und int *p = &a[1]; liest *(p + 2) das Element a[3], also 40. Die Zuweisung p += 3; versetzt den Zeiger selbst auf a[4] mit dem Wert 50. Von dort liest *(p - 1) den Wert 40. p++, p--, p += n und p -= n verwenden alle Elementschritte.

Positionen subtrahieren, um Elemente zu zählen

&a[5] - &a[1] ist 4, und die Umkehrung der Operanden ergibt -4. Das Ergebnis zählt bereits Elemente; dividiere es nicht durch sizeof(int). Sein vorzeichenbehafteter Typ ist ptrdiff_t, deklariert in <stddef.h>, und %td gibt es aus.

Subtrahiere nur Zeiger in dasselbe Array, einschließlich der Position unmittelbar hinter dessen Ende, und nur, wenn das Ergebnis in ptrdiff_t darstellbar ist. Diese Operation beschreibt Positionen innerhalb dieses Arrays. Die Subtraktion der Adressen nicht zusammengehöriger Variablen ist undefiniertes Verhalten, selbst wenn die ausgegebenen Zahlen zufällig nahe beieinanderliegen.

Die Position unmittelbar hinter dem Ende als Schranke verwenden

Bei sechs Elementen ist a + 6 ein gültiger Zeiger unmittelbar hinter das letzte Arrayelement. Er kann als Schranke dienen und bei gültigen Subtraktionen innerhalb desselben Arrays verwendet werden, darf aber nicht dereferenziert werden. a + 7 und a - 1 sind bereits beim Bilden undefiniertes Verhalten; eine spätere Dereferenzierung zu vermeiden, behebt das nicht.

for (int *p = a; p < a + 6; p++) {
    printf("%d\n", *p);
}

Der Schleifenkörper läuft für die Indizes 0 bis 5. Nach dem letzten Inkrement ist p gleich a + 6, und die nächste Prüfung stoppt die Schleife. Mit <= könnte der Schleifenkörper auf diese Position zugreifen, an der kein Element liegt.

Für die Regeln der Zeigerarithmetik verhält sich ein einzelnes Objekt wie ein Array mit einem Element. Du darfst &x + 1 bilden, aber nicht verwenden, um eine vermeintlich nächste Variable zu lesen.

Nur sinnvoll vergleichbare Positionen vergleichen

Ordnungsoperatoren wie < vergleichen Positionen innerhalb eines Arrays. Ordne keine Zeiger auf nicht zusammengehörige Objekte. Gleichheit und Ungleichheit lassen sich bei kompatiblen Zeigertypen vergleichen und zur Prüfung auf einen Nullzeiger verwenden.

Du kannst weder zwei Zeiger addieren noch Zeiger multiplizieren oder im Standard-C Arithmetik mit einem void * oder einem Funktionszeiger betreiben. Um die Mitte eines Bereichs [p, q) innerhalb desselben Arrays zu finden, verwende p + (q - p) / 2: Subtrahiere die Positionen, um eine Anzahl zu erhalten, dividiere diese Anzahl und gehe dann von p aus weiter.

Ein Array ist ein Block aus Elementen. Ein Zeiger ist ein separates Objekt, das eine Adresse enthält. Ihr enger Zusammenhang entsteht durch eine automatische Konvertierung, die in den meisten Ausdrücken stattfindet, nicht dadurch, dass die beiden Objekte derselben Art wären.

Einen Arrayausdruck konvertieren

int a[5] = {3, 1, 4, 1, 5};
int *p = a;

Hier wird a in einen Zeiger auf a[0] umgewandelt. Diese Array-zu-Zeiger-Konvertierung macht den Initialisierer gleichwertig zu &a[0]. Sowohl *p als auch a[0] lesen den Wert 3.

C definiert den Indexzugriff über Arithmetik: a[i] bedeutet *(a + i). Daher funktioniert auch p[3] und liest den Wert 1. &a[i] und a + i bezeichnen dasselbe Element. Sogar 3[a] hat dieselbe definierte Bedeutung wie a[3], obwohl die übliche Schreibweise viel klarer ist.

Erkennen, wann das gesamte Array ein Array bleibt

Die Konvertierung findet bei Operanden von sizeof oder dem unären & nicht statt. Sie findet auch nicht bei typeof und typeof_unqual aus C23 statt oder wenn ein Zeichenkettenliteral ein Zeichenarray initialisiert.

Du kannst einem Array keine neue Adresse zuweisen und seinen Namen nicht erhöhen: a = p; und a++; sind ungültig. Du kannst p neu ausrichten, etwa mit p = a + 2;. Kopiere Arrayinhalte mit einer Schleife über die Elemente oder einem geeigneten memcpy-Aufruf.

Den angepassten Parametertyp verfolgen

int sum(const int *values, size_t n) {
    int total = 0;
    for (size_t i = 0; i < n; i++) total += values[i];
    return total;
}

Der Aufrufer stellt sowohl eine Adresse als auch eine Anzahl bereit. Für das obige Array besucht sum(a + 2, 3) die ursprünglichen Indizes 2, 3 und 4 und addiert 4, 1 und 5, um 10 zurückzugeben. Innerhalb der Funktion bezieht sich Index 0 auf den übergebenen Anfangszeiger.

In einer Funktionsparameterliste deklarieren int a[], int a[10] und int *a jeweils einen Zeigerparameter. Die einfache Schreibweise [10] liefert keine überprüfte Schranke und überträgt keine Länge. Innerhalb einer solchen Funktion misst sizeof a einen Zeiger. Der Ausdruck sizeof a / sizeof a[0] würde auf einem System mit 8-Byte-Zeigern und 4-Byte-int den Wert 2 ergeben, unabhängig von der tatsächlichen Arraylänge des Aufrufers.

Einen Elementzeiger von einem Arrayzeiger unterscheiden

a wird in int * umgewandelt, während &a den Typ int (*)[5] hat, einen Zeiger auf das gesamte Array mit fünf Elementen. Beide bezeichnen den Anfang desselben Speicherbereichs, aber die Arithmetik folgt ihren unterschiedlichen Typen. a + 1 rückt um einen int vor, bei dieser Anordnung also um 4 Byte. &a + 1 rückt um ein gesamtes Array oder 20 Byte bis zur Position unmittelbar hinter dessen Ende vor.

Eine ausgegebene Anfangsadresse kann diesen Typunterschied nicht erkennen lassen. Lies die Deklaration und notiere beim Verfolgen eines Ausdrucks den referenzierten Typ neben dem Zeiger.

Eine Zeigerschleife braucht eine aktuelle Position und eine Abbruchregel. Ein Array mit bekannter Elementanzahl verwendet einen Endzeiger; eine Zeichenkette verwendet ihr abschließendes '\0'. Wähle die Form, die am deutlichsten zeigt, welche Elemente besucht werden.

Einen Bereich mit bekannter Länge durchlaufen

int a[] = {3, 1, 4, 1, 5};
int total = 0;
for (const int *p = a; p < a + 5; p++) {
    total += *p;
}

Die laufenden Summen sind 3, 4, 8, 9 und 14. Eine indexbasierte Schleife, die a[i] für Indizes unter 5 addiert, liefert dasselbe Ergebnis. Moderne optimierende Compiler erzeugen für diese Formen häufig ähnlichen Code; die Zeigersyntax allein verspricht keinen Geschwindigkeitsvorteil.

Vor oder nach dem Versetzen lesen

Zeigt p in {3, 1, 4} auf die 3, setzt int v = *p++; die Variable v auf 3 und lässt p auf die 1 zeigen. Das Postfix-Inkrement liefert den alten Zeigerwert an * und aktualisiert den Zeiger. *++p geht zuerst zum nächsten Element und liest es dann. (*p)++ ändert das aktuelle Element und versetzt den Zeiger nicht.

Am abschließenden Nullzeichen stoppen

size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p != '\0') p++;
    return (size_t)(p - s);
}

Bei "pointer" stoppt p auf dem abschließenden Nullzeichen, sieben Positionen vom Anfang entfernt. Das Ergebnis schließt dieses Nullzeichen nicht ein. Eine Zeichenzählung verwendet denselben Durchlauf: Beim Durchsuchen von "mississippi" und Erhöhen eines Zählers für jedes *p == 's' werden vier Treffer unter elf Buchstaben gezählt.

Ein Zeiger in die Mitte einer Zeichenkette ermöglicht den Zugriff auf ihren hinteren Teil. Bei const char *msg = "hello world"; gibt puts(msg + 6) den Text "world" aus. Die vorherigen Zeichen bleiben an ihrer Stelle.

Das abschließende Nullzeichen mitkopieren

char destination[4];
const char *src = "cat";
char *dst = destination;
while ((*dst++ = *src++) != '\0') {
}

Jede Iteration weist ein Zeichen zu, prüft den zugewiesenen Wert und setzt beide Zeiger weiter. Die letzte Iteration kopiert '\0', sodass das Ziel eine vollständige Zeichenkette ist. Beide Zeiger stehen danach unmittelbar hinter ihren abschließenden Nullzeichen. Der Speicher benötigt die Textlänge plus ein Byte; fehlt dieses zusätzliche Byte, entsteht ein Pufferüberlauf. Dieses Kopiermuster setzt außerdem voraus, dass Quell- und Zielbereich nicht überlappen.

Von beiden Enden aus umkehren

Ermittle bei einer beschreibbaren Zeichenkette zuerst ihre Länge. Ist die Länge null, stoppe, bevor du einen Zeiger auf das letzte Zeichen bildest. Setze andernfalls left = s und right = s + length - 1. Solange left < right gilt, vertausche die Zeichen, erhöhe left und verringere right. Für "stressed" ergeben vier Vertauschungen "desserts"; das abschließende Nullzeichen bleibt am ursprünglichen Ende.

Die Prüfung auf eine leere Zeichenkette ist wichtig, weil die Subtraktion von 1 von ihrem Anfangszeiger einen Zeiger vor das Array bilden würde.

Beschreibbaren Zeichenspeicher wählen

char word[] = "hello"; erstellt ein veränderbares Array mit sechs Byte einschließlich des abschließenden Nullzeichens. const char *word = "hello"; zeigt auf ein Zeichenkettenliteral mit statischer Speicherdauer. Ein Zeichenkettenliteral zu ändern, ist undefiniertes Verhalten, selbst wenn eine Deklaration char * ohne const verwendet. Verwende const char *, damit versehentliche Schreibzugriffe zu einem Übersetzungsfehler werden.

Eine Arrayschleife muss vor der Position unmittelbar hinter dem Ende stoppen, und ein Zeichenkettendurchlauf muss innerhalb des zugänglichen Speichers tatsächlich ein abschließendes Nullzeichen antreffen. Ein Zeiger enthält weder eine Länge noch eine Garantie, dass die Bytes eine Zeichenkette bilden.

Ein Zeiger ist ein gespeichertes Objekt und hat daher eine Adresse, die ein anderer Zeiger enthalten kann. Ein Zeiger auf einen Zeiger fügt einen weiteren Schritt zwischen dem Ausdruck und den endgültigen Daten hinzu.

Den Pfeilen einzeln folgen

int x = 7;
int *p = &x;
int **pp = &p;

Verwende Adressen zur Veranschaulichung: x bei 0x2000 enthält 7; p bei 0x3000 enthält 0x2000; pp bei 0x4000 enthält 0x3000. Die Auswertung von *pp erreicht p, dessen Wert den Typ int * hat. Die Auswertung von **pp folgt diesem Zeiger weiter zu x, einem int.

&p hat eine Zeigerebene mehr als p; jede Dereferenzierung entfernt eine Ebene. Die Initialisierung von int **pp mit &x passt nicht, weil &x den Typ int * hat.

Die Zuweisungsebene wählen

Bei einer weiteren noch existierenden Ganzzahl y ändert **pp = 9; die Variable x. Die Zuweisung *pp = &y; ändert den Zeiger p, sodass spätere Verwendungen von **pp die Variable y erreichen. Der aktuelle Wert von x bleibt unverändert. Ist q ein weiterer int *, ändert pp = &q; nur den äußeren Zeiger, sodass sein erster Pfeil statt p nun q erreicht.

Zähle nicht nur die Sternchen, sondern prüfe auch das Objekt auf jeder Ebene. Vor der Auswertung von **pp müssen sowohl der Weg zum Zeigerobjekt als auch der Weg von diesem Objekt zur Ganzzahl gültig sein.

Den Zeichenkettenzeiger eines Aufrufers versetzen

void skip_spaces(const char **s) {
    while (**s == ' ') {
        (*s)++;
    }
}

/* In the caller: */
const char *text = "   hi";
skip_spaces(&text);
puts(text);

Der Aufrufer übergibt die Adresse seiner Zeigervariablen. *s bezeichnet daher text; **s liest das aktuelle Zeichen. Jedes (*s)++ setzt text um ein Zeichen weiter. Nach drei Iterationen zeigt der Zeiger auf 'h', und puts gibt "hi" aus. Die Funktion benötigt einen gültigen Zeiger auf einen Zeiger in eine nullterminierte Zeichenkette.

Eine Version mit dem Parameter const char *s, die s erhöht, ändert nur eine lokale Kopie. Auch die Klammern in (*s)++ sind unverzichtbar: *s++ erhöht den äußeren lokalen Zeiger statt des Zeichenzeigers des Aufrufers. In const char **s sind die Zeichen über diesen Zugriffsweg schreibgeschützt, der Zeiger des Aufrufers darf aber versetzt werden.

Einen Ausgabezeiger einer Bibliotheksfunktion lesen

strtol aus <stdlib.h> verwendet einen Ausgabeparameter vom Typ char **:

char *end;
long number = strtol("42abc", &end, 10);

Die Funktion gibt 42 zurück und speichert in end einen Zeiger auf das erste nicht verwendete Zeichen, sodass der Zeiger nun "abc" erreicht. Ist der Endzeiger gleich dem Anfangszeiger, wurden keine Ziffern konvertiert. Eine vollständig geprüfte Zahlenkonvertierung behandelt auch Wertebereichsfehler; die Aufgabe des Zeigers ist hier, die Stoppposition anzugeben.

Ein Array kann Zeiger als Elemente speichern. Ein zweidimensionales Array speichert dagegen ganze Zeilen als Elemente. Beide erlauben zwei Indizes, unterscheiden sich aber in ihrer Speicherung und den konvertierten Zeigertypen.

Adressen getrennter Zeichenketten speichern

const char *days[] = {"Mon", "Tue", "Wed"};

days enthält drei Zeichenzeiger. Jeder zeigt auf ein separates Zeichenkettenliteral. days[1] ist der Zeiger auf "Tue", und days[1][0] liest 'T'. Bei Objektzeigern mit 8 Byte ist sizeof days gleich 24, unabhängig von den Längen der Zeichenketten. Die Zeichenketten selbst belegen Speicher an anderer Stelle.

Die Längen können unterschiedlich sein, sodass eine unregelmäßige Sammlung entsteht. Um die Liste neu zu ordnen, können Zeigerelemente vertauscht werden, ohne den Text zu kopieren. Die Zuweisung days[0] = "Thursday"; ist erlaubt: Das Zeigerelement kann geändert werden, obwohl die darüber erreichten Zeichen schreibgeschützt sind.

In den meisten Ausdrücken wird days in einen Zeiger auf sein erstes Element umgewandelt. Da ein Element ein const char * ist, lautet der konvertierte Typ const char **:

for (const char **d = days; d < days + 3; d++) {
    puts(*d);
}

Die Schleife geht pro Iteration um ein Zeigerelement weiter. *d liefert den Zeichenzeiger, den puts benötigt.

Kommandozeilenzeichenketten lesen

int main(int argc, char *argv[]) erhält denselben Parametertyp wie char **argv. argc ist nicht negativ und zählt die verfügbaren Zeichenketten. Ist der Wert positiv, steht argv[0] für den Programmnamen oder für eine leere Zeichenkette, falls dieser Name nicht verfügbar ist. Benutzerargumente belegen die Indizes 1 bis argc - 1, und argv[argc] ist ein Nullzeiger.

Bei einem typischen Aufruf ./greet Ada 42 ist argc gleich 3, argv[1] zeigt auf "Ada" und argv[2] auf "42". Das letzte Argument ist Text, bis eine Konvertierung wie strtol es liest. argv[1][0] ist 'A'. Prüfe argc > 2, bevor du argv[2] verwendest.

Eine Schleife, die Benutzerargumente ausgibt, kann for (int i = 1; i < argc; i++) puts(argv[i]); verwenden. Um stattdessen von argv + 1 bis zu einem Nullzeiger zu gehen, prüfe zuerst argc > 0; ist argc null, gibt es keinen Bereich von Benutzerargumenten, der sich so beginnen lässt. Argumentzeichenketten sind im Gegensatz zu Zeichenkettenliteralen veränderbar.

Ganzen Zeilen folgen

int grid[3][4] enthält zwölf Ganzzahlen in zeilenweiser Speicherung: zuerst die gesamte Zeile 0, dann Zeile 1 und dann Zeile 2. Bei int mit 4 Byte belegt jede Zeile 16 Byte. grid[2][1] liegt 36 Byte hinter grid[0][0]: Zwei ganze Zeilen ergeben 32 Byte und die Spalte 4.

grid + 1 rückt um eine Zeile vor. Eine Funktion, die es entgegennimmt, kann int g[][4] oder int (*g)[4] mit einer separaten Zeilenanzahl verwenden. Sie kann nicht int ** verwenden: Das Array enthält keine gespeicherten Zeilenzeiger, die sich dereferenzieren ließen. Eine explizite Typumwandlung kann diese fehlenden Zeiger nicht erzeugen.

Entsprechend besitzt char names[3][6] achtzehn Zeichenplätze in Zeilen fester Größe. const char *names[3] besitzt drei Zeigerplätze, die auf Zeichenketten unterschiedlicher Länge verweisen können.

Ein Funktionszeiger speichert einen Verweis auf eine Funktion, die später aufgerufen werden kann. Sein Typ umfasst den Rückgabetyp und die Parametertypen. Diese Typen müssen zur Funktion passen, die über den Zeiger verwendet wird.

Den Zeigernamen in Klammern setzen

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int (*op)(int, int) = add;

Lies von op aus: Es ist ein Zeiger, das referenzierte Objekt ist eine Funktion, die zwei int entgegennimmt, und diese Funktion gibt einen int zurück. Ohne die Klammern deklariert int *op(int, int); eine Funktion, die einen Ganzzahlzeiger zurückgibt. Die Klammern ändern die Bedeutung der Deklaration.

In diesem Initialisierer wird ein Funktionsname in einen Funktionszeiger umgewandelt. op = &add; ist gleichwertig zu op = add;. Sowohl op(6, 3) als auch (*op)(6, 3) rufen add auf und geben 9 zurück. Die Zuweisung op = sub; führt dazu, dass derselbe Aufruf 3 zurückgibt. Am Aufrufausdruck hat sich nichts geändert, außer der im Zeiger gespeicherten Funktion.

Die Signatur kompatibel halten

Ein Zeiger vom Typ int (*)(int, int) kann eine Funktion, die double entgegennimmt und zurückgibt, nicht sicher aufrufen. Beispielsweise erzeugt die Zuweisung von sqrt an ihn eine Meldung über inkompatible Typen. Eine explizite Typumwandlung des Funktionszeigers, die eine Meldung unterdrückt, macht einen nicht passenden Aufruf nicht gültig; das Verhalten ist undefiniert.

Standard-C behandelt Objektzeiger und Funktionszeiger getrennt. void * ist der generische Objektzeigertyp und kein portabler Speicher für einen Funktionszeiger. Funktionszeiger unterstützen Prüfungen auf Gleichheit und Ungleichheit, aber keine Zeigerarithmetik.

Ein Null-Funktionszeiger bedeutet, dass keine aufrufbare Funktion vorhanden ist. Erlaubt eine Schnittstelle diesen Zustand, prüfe ihn:

if (op != NULL) {
    int result = op(6, 3);
    printf("%d\n", result);
}

Ein Aufruf über einen Null-Funktionszeiger ist undefiniertes Verhalten.

Den Typ einmal benennen

typedef int (*binop)(int, int);
binop ops[] = {add, sub, mul};

Das typedef benennt einen Zeigertyp. binop selected = mul; deklariert einen Zeiger; binop pick(char symbol); deklariert eine Funktion, die einen solchen zurückgibt. Ohne das typedef würde diese Rückgabedeklaration int (*pick(char symbol))(int, int); lauten.

Ein Array von Funktionszeigern ist eine Sprungtabelle. ops[2](6, 3) wählt mul aus und gibt 18 zurück. Prüfe bei einem vorzeichenbehafteten Auswahlindex i die Bedingung i >= 0 && i < 3, bevor du ops[i] auswertest. Ein Indexzugriff außerhalb der Tabelle ist ungültig, selbst wenn jede gespeicherte Funktion ansonsten aufrufbar ist.

Größere Deklarationen von innen nach außen lesen

Beginne beim Namen und löse Klammern und Postfixteile auf, bevor du weiter nach außen gehst. In int (*table[3])(int, int) macht table[3] ein Array aus drei Elementen, * macht jedes Element zu einem Zeiger, und (int, int) macht dessen Ziel zu einer Funktion, die int zurückgibt.

In char *(*f)(const char *) ist f ein Zeiger auf eine Funktion, die einen const char * entgegennimmt; diese Funktion gibt einen char * zurück. Halte die Anforderungen an die Lebensdauer des zurückgegebenen Zeigers von den Anforderungen an kompatible Aufrufe über den Funktionszeiger getrennt.

Eine Rückruffunktion ist eine Funktion, die einer anderen Funktion übergeben wird, welche sie im Rahmen ihrer Arbeit aufruft. Das trennt die allgemeine Durchlauf- oder Sortieroperation von der konkreten Aktion oder Reihenfolge, die du auswählst.

Eine Operation übergeben, ohne sie aufzurufen

void twice(int *x) { *x *= 2; }

void for_each(int *a, size_t n, void (*fn)(int *)) {
    for (size_t i = 0; i < n; i++) fn(&a[i]);
}

Für int v[] = {1, 2, 3}; erzeugt for_each(v, 3, twice); die Werte {2, 4, 6}. Der Funktionsname liefert einen Zeiger. twice() würde versuchen, die Funktion sofort ohne das erforderliche Argument aufzurufen, statt eine Operation für spätere Aufrufe bereitzustellen.

Den Typ aus einem generischen Objektzeiger zurückgewinnen

Ein void * kann einen Objektzeiger aufnehmen und zurück in den ursprünglichen Typ umgewandelt werden. Er kann nicht dereferenziert oder in Standard-C für Zeigerarithmetik verwendet werden, weil er keinen Elementtyp vorgibt. Erhalte Qualifizierer: Schreibgeschützte Daten werden über const void * und anschließend über einen geeigneten Zeiger auf konstante Daten weitergegeben.

qsort aus <stdlib.h> erhält eine Basisadresse, eine Elementanzahl, eine Elementgröße in Bytes und eine Vergleichsfunktion als Rückruffunktion. Die Rückruffunktion hat den Typ int (*)(const void *, const void *). Jedes Argument zeigt auf ein Arrayelement, und das Vorzeichen des Rückgabewerts gibt an, wohin das erste Element gehört:

Ganzzahlen ohne Überlauf sortieren

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

/* In the caller: */
int v[] = {42, -7, 19, 0, 3};
qsort(v, 5, sizeof v[0], cmp_int);

Das Array wird zu {-7, 0, 3, 19, 42}. Vergleiche ergeben 0 oder 1, sodass der Rückgabeausdruck nur -1, 0 oder 1 ergibt. Kehrst du den Ordnungs­ausdruck zu (y > x) - (y < x) um, wird absteigend sortiert.

Verwende return x - y; nicht für beliebige vorzeichenbehaftete Ganzzahlen. Bei einem int mit 32 Bit überschreitet die Subtraktion von -2000000000 von 2000000000 den Wert INT_MAX. Ein Überlauf bei vorzeichenbehafteten Ganzzahlen ist undefiniertes Verhalten, sodass weder ein Ergebnis durch Wraparound noch ein zuverlässiges Vergleichsvorzeichen zugesichert ist.

Zeiger auf Zeichenketten sortieren

int cmp_str(const void *a, const void *b) {
    return strcmp(*(const char *const *)a,
                  *(const char *const *)b);
}

const char *names[] = {"Lin", "Ada", "Grace"};
qsort(names, 3, sizeof names[0], cmp_str);

Binde für strcmp die Headerdatei <string.h> ein. Ein Arrayelement ist hier selbst ein Zeiger. Die Rückruffunktion erhält eine Adresse dieses Zeigerelements, sodass einmaliges Dereferenzieren die Zeichenkettenadresse liefert. Das hinzugefügte innere const verhindert, dass das Element über diesen Zugriffsweg geändert wird. Nach dem Sortieren ist die Reihenfolge "Ada", "Grace", "Lin".

strcmp(a, b) würde die Bytes der Zeigerplätze als Text lesen. Verwende außerdem sizeof names[0], die Größe eines Zeigerelements, nicht sizeof(char) oder die Länge eines Namens.

Vergleichsfunktionen dürfen Elemente nicht ändern und müssen konsistente Ergebnisse liefern, einschließlich einer transitiven Reihenfolge. qsort verspricht nicht, die Reihenfolge von Elementen zu erhalten, die als gleich verglichen werden. bsearch akzeptiert dieselbe Form von Vergleichsfunktion, um ein bereits nach dieser Reihenfolge sortiertes Array zu durchsuchen.