Dalla A alla Z passando per C - Robotica

assegna al puntatore p l’indirizzo del primo elemento del vettore vett. Il vettore viene riempito
con il primo ciclo, accedendo ai singoli elementi attraverso il puntatore p. Per mostrare che
effettivamente gli elementi del vettore sono stati correttamente scritti, tali elementi vengono
scritti a video accedendo al vettore attraverso il suo identificatore vett.
Il C è pensato per essere molto vicino al processore e alle sue strutture; non dovrebbe perciò
stupire la scelta degli autori del linguaggio di rappresentare un vettore con l’indirizzo del suo
primo elemento. Puntatori e vettori sono perciò concetti intercambiabili e ad un puntatore si
può applicare un indice tramite l’operatore parentesi-quadre senza che questo provochi errori
o messaggi di attenzione. Il nome di un vettore è diverso da un puntatore in quanto non gli
può essere assegnato un nuovo valore: si tratta di un indirizzo costante istanziato all’atto della
compilazione del programma.
Ai puntatori possono essere sommati e sottratti numeri interi: il risultato della somma di
un puntatore e di un numero intero n è il puntatore all’elemento numero n del vettore. Il
numero intero non rappresenta cioè il numero di byte da aggiungere nell’indirizzo, ma il numero
di elementi, il fattore di scala appropriato viene applicato dal compilatore in base al tipo di
puntatore oggetto di operazione aritmetica. È possibile quindi incrementare/decrementare un
puntatore, come pure fare la differenza (ma non la somma) tra puntatori dello stesso tipo, e
il risultato è un numero intero). L’aritmetica su puntatori generici (puntatori a void) con gcc
usa 1 byte come dimensione dell’elemento puntato, mentre non è definita secondo lo standard
del linguaggio. Il “puntatore nullo” vale zero e non è un puntatore valido; nelle funzioni che
ritornano un puntatore è spesso ritornato come segnalazione di errore. La macro NULL vale 0,
e 0 è confrontabile con qualunque puntatore.
Gli operatori più importanti per usare i puntatori sono “*” (si legge “il puntato da”) e “&”
(“l’indirizzo di”).
Esempi:
int i, v[10], *p; /* un numero intero, un vettore e un puntatore:
"è intero ogni elemento del vettore v, di dimensione 10"
"è intero quello che è puntato da p" */
p = v; /* assegno a p il valore di v, l’indirizzo del primo elemento */
p = &v[0]; /* come sopra */
p = &v[4]; /* assegno a p l’indirizzo del quinto elemento di v */
p = v + 4; /* come sopra */
p++; /* incremento p */
i = p - v; /* assegno 5 a i (in conseguenza delle due righe precedenti) */
Nell’esempio che segue, viene effettuato un ciclo fintanto che non viene incontrato un valore
nullo nel vettore v. Il puntatore p viene utilizzato per scorrere il vettore, essendo inizializzato
all’indirizzo del primo elemento del vettore stesso. Il ciclo termina quando il valore puntato
da p, cioè *p, è nullo. Il ciclo calcola la somma di tutti i valori considerati, memorizzandola
in sum. Si noti che deve esserci almeno un elemento di v che vale zero, altrimenti il puntatore
assumerà valori non validi andando ad accedere aree di memoria poste oltre la fine del vettore. Il
linguaggio non effettua alcun controllo implicito su puntatori e indici di vettori, quindi questo è
un tipico errore logico dalle conseguenze spesso imprevedibili. Infatti tali conseguenze dipendono
dal contenuto della memoria posta dopo quella allocata per il vettore v.
sum = 0;
for (p = v; *p; p++)
sum += *p;
90