WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C

Zeigerarithmetik in C

Verschiebe Zeiger in Elementschritten, nutze die Position direkt hinter dem Array und berechne Differenzen, die in `ptrdiff_t` passen.

Version: ISO C23; implementation support may vary

Syntax

ISO C23 (implementation support may vary):
T *p;                     // T is a complete object type
p + n;  n + p;  p - n;    // n has integer type; result has p's type
p += n; p -= n;           // update a modifiable pointer variable
p - q;                    // compatible complete pointed-to types, possibly differently qualified; result: ptrdiff_t

In C verschiebt die Zeigerarithmetik einen Zeiger p auf einen vollständigen Objekttyp um eine ganzzahlige Anzahl von Elementen, nicht von Bytes. p + n und n + p verschieben ihn um n Positionen, p - n in die Gegenrichtung. Der Ergebnistyp bleibt der Typ von p; p += n speichert die neue Position in p. Zwei Zeiger lassen sich nicht addieren. Arithmetik mit void * oder Funktionszeigern ist eine GNU-C-Erweiterung, kein Bestandteil von ISO C23.

Ausgangszeiger und Ergebnis müssen während der Lebensdauer desselben Arrays jeweils auf eines seiner Elemente oder direkt hinter sein letztes Element zeigen. Die Position direkt hinter dem Array darf als Endmarke dienen; man darf von dort auch zurückgehen, sie aber nicht dereferenzieren. Schon das Berechnen einer Position vor dem ersten Element oder weiter als direkt hinter dem letzten Element führt zu undefiniertem Verhalten. Für diese Operatoren verhält sich ein Objekt, das kein Arrayelement ist, wie ein Array mit einem Element.

p - q erfordert Zeiger auf kompatible vollständige Objekttypen, deren Qualifizierer sich unterscheiden dürfen. Beide müssen im beschriebenen Sinn zum selben Array gehören. Das Ergebnis ist die vorzeichenbehaftete Indexdifferenz in Elementen vom Typ ptrdiff_t aus <stddef.h>. Passt die Differenz nicht in diesen Typ, ist das Verhalten undefiniert. Verwende %td in printf. Bei zwei Operanden arithmetischen Typs rechnen + und - dagegen numerisch mit den üblichen arithmetischen Konvertierungen; das unäre - negiert eine Zahl, keinen Zeiger.

Behandle vor cur += lf oder w += seg einen möglichen Fehlerwert NULL und prüfe die Verschiebung gegen den verbleibenden Arraybereich. Ein von NULL verschiedener Zeiger beweist weder Gültigkeit noch eingehaltene Grenzen. Prüfe bei einer Größenberechnung in Bytes vor der Multiplikation count <= SIZE_MAX / sizeof *p, wobei count den Typ size_t hat und SIZE_MAX aus <stdint.h> stammt. Das prüft weder die Arraygrenzen noch, ob cur - r in ptrdiff_t passt.

Beispiele

#include <stddef.h>
#include <stdio.h>

int main(void)
{
    int a[] = {10, 20, 30, 40};
    int *r = a;
    int *cur = r;
    size_t lf = 2;
    cur += lf;

    int *w = cur;
    size_t seg = 2;
    w += seg;

    printf("%d %td %td %td %d\n", *cur, cur - r, w - r, r - w, *(w - 1));
    return 0;
}

Ergebnis

30 2 4 -4 40

`cur` zeigt auf `30`, `w` direkt hinter das Array. `cur - r`, `w - r` und `r - w` ergeben der Reihe nach `2`, `4` und `-4`. `*(w - 1)` liest `40`, ohne `w` zu dereferenzieren.

Zugehörige Lektionen

  • C · Lektion 81 · Fortgeschritten · Version: 3

Quellen