Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Aritmetica dei puntatori in C

Sposta i puntatori per elementi, usa la posizione subito dopo la fine dell’array e calcola differenze rappresentabili in `ptrdiff_t`.

Versione: ISO C23; implementation support may vary

Sintassi

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, l’aritmetica dei puntatori sposta un puntatore p a un tipo oggetto completo di un numero intero di elementi, non di byte. p + n e n + p lo spostano di n posizioni; p - n lo sposta nel verso opposto. Il risultato mantiene il tipo di p; p += n memorizza la nuova posizione in p. Non si possono sommare due puntatori. L’aritmetica su void * o sui puntatori a funzione è un’estensione di GNU C, non una regola di ISO C23.

Il puntatore iniziale e il risultato devono indicare ciascuno un elemento dello stesso array durante il suo tempo di vita oppure la posizione subito dopo l’ultimo elemento. Questa posizione può servire come marcatore di fine e consente di tornare indietro, ma non si può dereferenziare. Anche solo calcolare una posizione prima del primo elemento o oltre quella subito dopo l’ultimo ha comportamento indefinito. Per questi operatori, un oggetto che non è un elemento di un array si comporta come un array di un solo elemento.

p - q richiede puntatori a tipi oggetto completi compatibili, che possono avere qualificatori diversi. Entrambi devono appartenere allo stesso array nel senso appena descritto. Il risultato è la differenza con segno degli indici, in elementi, di tipo ptrdiff_t, definito in <stddef.h>. Se non è rappresentabile, il comportamento è indefinito. Usa %td in printf. Con due operandi aritmetici, invece, + e - operano su numeri applicando le consuete conversioni aritmetiche; il - unario calcola l’opposto di un numero, non di un puntatore.

Prima di cur += lf o w += seg, gestisci un eventuale risultato di errore NULL e controlla lo spostamento rispetto all’intervallo rimanente dell’array. Un puntatore non nullo non dimostra né la validità né il rispetto dei limiti. Per una dimensione in byte, verifica count <= SIZE_MAX / sizeof *p prima di moltiplicare, con count di tipo size_t e SIZE_MAX definito in <stdint.h>. Questo controllo non verifica né i limiti dell’array né che cur - r sia rappresentabile in ptrdiff_t.

Esempi

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

Risultato

30 2 4 -4 40

`cur` punta a `30` e `w` si trova subito dopo l’array. `cur - r`, `w - r` e `r - w` danno rispettivamente `2`, `4` e `-4`. `*(w - 1)` legge `40` senza dereferenziare `w`.

Lezioni correlate

  • C · Lezione 81 · Avanzato · Versione: 3

Fonti