Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C

Arithmétique des pointeurs en C

Déplacez des pointeurs en nombre d’éléments, utilisez la position juste après le tableau et calculez des écarts représentables en `ptrdiff_t`.

Version : ISO C23; implementation support may vary

Syntaxe

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

En C, l’arithmétique des pointeurs décale un pointeur p vers un type objet complet d’un nombre entier d’éléments, et non d’octets. p + n et n + p le déplacent de n positions, et p - n le déplace en sens inverse. Le résultat garde le type de p ; p += n enregistre la nouvelle position dans p. On ne peut pas additionner deux pointeurs. L’arithmétique sur void * ou sur les pointeurs de fonction est une extension de GNU C, pas une règle d’ISO C23.

Le pointeur de départ et le résultat doivent chacun désigner un élément du même tableau pendant sa durée de vie, ou la position juste après son dernier élément. Cette position peut servir de marqueur de fin et permet de revenir en arrière, mais ne doit pas être déréférencée. Le simple calcul d’une position avant le premier élément ou au-delà de cette limite entraîne un comportement indéfini. Pour ces opérateurs, un objet qui n’est pas un élément de tableau se comporte comme un tableau d’un seul élément.

p - q exige des pointeurs vers des types objets complets compatibles, dont les qualificatifs peuvent différer. Les deux pointeurs doivent appartenir au même tableau au sens ci-dessus. Le résultat est la différence signée des indices, en éléments, de type ptrdiff_t défini dans <stddef.h>. Si elle n’est pas représentable, le comportement est indéfini. Utilisez %td dans printf. Avec deux opérandes arithmétiques, + et - effectuent au contraire des opérations numériques selon les conversions arithmétiques usuelles ; le - unaire prend l’opposé d’un nombre, pas d’un pointeur.

Avant cur += lf ou w += seg, traitez tout résultat d’erreur NULL et vérifiez le décalage par rapport à la plage restante du tableau. Un pointeur non nul ne prouve ni sa validité ni le respect des bornes. Pour une taille en octets, vérifiez count <= SIZE_MAX / sizeof *p avant la multiplication, avec count de type size_t et SIZE_MAX défini dans <stdint.h>. Ce test ne vérifie ni les bornes du tableau ni la représentabilité de cur - r en ptrdiff_t.

Exemples

#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;
}

Résultat

30 2 4 -4 40

`cur` pointe sur `30` et `w` se trouve juste après le tableau. `cur - r`, `w - r` et `r - w` donnent respectivement `2`, `4` et `-4`. `*(w - 1)` lit `40` sans déréférencer `w`.

Leçons associées

  • C · Leçon 81 · Avancé · Version : 3

Sources