Indirizzi, scanf e puntatori

Nella lezione 02B ogni variabile era una casella con quattro cose: nome, tipo, indirizzo e valore. Finora abbiamo usato solo il valore. Adesso tocca all'indirizzo.

Pensa a una via con le case numerate. In ogni casa abita qualcuno. Il numero civico dice dove sta la casa; chi ci abita è che cosa c'è dentro. Sono due informazioni diverse: se cambia l'inquilino, il numero civico resta lo stesso.

In memoria è uguale:

• il valore di x è quello che c'è nella casella, per esempio 5;
• l'indirizzo di x è il numero della casella, per esempio 0x03FC.

L'indirizzo è un numero senza segno, unico per ogni posizione della memoria. Si scrive di solito in esadecimale, con il prefisso 0x (lezione 01 di Fondamenti), perché è più corto.

Come si legge. x è il contenuto della casella, &x è il suo numero civico. Il nome «referenziamento» viene dall'inglese reference, riferimento: con &x ottieni un riferimento a x.

Stampare gli indirizzi con %p (slide 5–6)

printf ha uno specificatore apposta per gli indirizzi: %p (da pointer). Il programma delle slide:

#include <stdio.h>

int main(void) {
    int x = 5;
    int y = 2;
    int z = x + y;

    printf("La var x all'indirizzo %p vale %d \n", &x, x);
    printf("La var y all'indirizzo %p vale %d \n", &y, y);
    printf("La var z all'indirizzo %p vale %d \n", &z, z);
}

Sul computer delle slide (Linux) ha stampato:

La var x all'indirizzo 0x7fffd0624e0c vale 5
La var y all'indirizzo 0x7fffd0624e08 vale 2
La var z all'indirizzo 0x7fffd0624e04 vale 7

Sul mio (Windows, gcc 16.1, con -Wall -Werror) ha stampato:

La var x all'indirizzo 00000076D3DFF75C vale 5
La var y all'indirizzo 00000076D3DFF758 vale 2
La var z all'indirizzo 00000076D3DFF754 vale 7

Tre cose da notare:

1. Il formato dipende dal sistema. Linux scrive 0x e le lettere minuscole; Windows scrive tutte le 16 cifre, senza 0x, con le maiuscole.
2. Gli indirizzi scendono di 4 in 4. Le tre variabili sono una sotto l'altra sullo stack, ognuna da 4 byte, come nel modello della memoria della 02B: lo stack cresce verso il basso.
3. Il numero cambia ogni volta. Rilanciando il programma si ottengono indirizzi diversi. Il valore concreto di un indirizzo non deve mai entrare nella logica del programma (slide 6): conta solo che indichi una posizione.

Negli schemi le slide usano indirizzi simbolici corti, come 0x03FC, 0x03F8, 0x03F4, per non scrivere 12 cifre ogni volta (slide 7). Lo faremo anche qui.

Finora i programmi stampavano soltanto. Un programma utile spesso deve anche ricevere dati: un numero, un voto, una quantità. In C si usa la funzione scanf.

Immagina scanf come un corriere. Va alla tastiera, prende il numero che scrivi e lo deve consegnare in una casella della memoria. Per farlo gli serve l'indirizzo della casella, non il suo contenuto. Per questo si scrive:

scanf("%d", &x);

• "%d" dice che cosa leggere: un intero, come in printf;
• &x dice dove scriverlo: all'indirizzo di x.

scanf aspetta che tu scriva il numero e prema Invio; solo allora va avanti.

Il programma passo per passo (slide 10–13)

#include <stdio.h>

int main(void) {
    int x, y, z;
    printf("Inserisci x: ");
    scanf("%d", &x);
    printf("Inserisci y: ");
    scanf("%d", &y);
    z = x + y;
    printf("%d + %d = %d\n", x, y, z);
}

Seguiamolo nella memoria, scrivendo 5 e poi 2.

scanf ha ricevuto gli indirizzi 0x03FC e 0x03F8, ed è lì che ha scritto 5 e 2.

Due numeri con una sola scanf (slide 14–17)

Una scanf può leggere più valori: un %d e un indirizzo per ciascuno.

scanf("%d%d", &x, &y);

Scrivendo 5 2 e Invio, il 5 va in x e il 2 in y. I due numeri possono essere separati da uno o più spazi, e anche da Invio: ho provato 5, una riga vuota e 2, e il risultato è lo stesso. Per %d gli spazi e gli a capo davanti a un numero vengono saltati.

senza_amp.c:5:13: error: format '%d' expects argument of type 'int *', but argument 2 has type 'int' [-Werror=format=]
    5 |     scanf("%d", n);
      |            ~^   ~
      |             |   |
      |             |   int
      |             int *

Chi usa il programma può scrivere qualunque cosa: una lettera, un numero con la virgola, niente. scanf prova a leggere seguendo il formato, e quando trova qualcosa che non va si ferma. In più restituisce un numero: quanti valori è riuscito a leggere.

int x, y;
int n = scanf("%d%d", &x, &y);

Tre prove (slide 19–21)

Il programma delle slide:

#include <stdio.h>

int main(void) {
    int x;
    printf("Inserisci un intero: ");
    int n = scanf("%d", &x);
    printf("Valori letti correttamente: %d\n", n);
    printf("x vale %d \n", x);
}

Le tre prove, rifatte sul mio computer:

Nel caso di 1234.56 il .56 non sparisce: resta in attesa, e la prossima scanf("%d", …) lo troverebbe. Ho provato con due scanf di fila: la seconda restituisce 0, perché un numero non può cominciare con il punto.

Nel caso di A il numero stampato è a caso: le slide scrivono ?????. Leggere una variabile mai inizializzata è un comportamento indefinito (slide 21): il C non promette niente su quello che succede.

Un valore di partenza (slide 23)

Se dai a x un valore iniziale, il caso sbagliato diventa riconoscibile:

int x = -1;

Con A il programma stampa Letti con successo 0 interi e x vale -1: la scanf fallita ha lasciato x com'era. Ma attenzione: il controllo vero è n, non il -1, perché anche chi usa il programma potrebbe scrivere proprio -1.

&x vale 0x03FC. Dove si può conservare questo numero? Un biglietto su cui è scritto un indirizzo: ecco che cos'è un puntatore.

Come si legge.

• int è il tipo degli interi; int* è il tipo dei puntatori a interi: contiene indirizzi di variabili int.
• float* è il puntatore a float, char* il puntatore a char, e così via.
• Per abitudine i nomi dei puntatori cominciano con p: pX è il puntatore a x. All'esame si usano nomi come pA, pSrc, pDst (scheda del corso).

int x = 5;
int* pX = &x;   // pX riceve l'indirizzo di x

Pezzo per pezzo (slide 27):

La regola dei tipi: se x è int, allora &x è int*. Per questo l'assegnamento pX = &x è compatibile: a sinistra e a destra c'è lo stesso tipo.

Anche il puntatore è una casella (slide 28–32)

pX è una variabile come le altre: occupa memoria e ha un suo indirizzo. Il programma delle slide:

#include <stdio.h>

int main(void) {
    int x = 5;
    int* pX;
    pX = &x;
    printf("Il ptr pX all'ind %p vale %p \n", &pX, pX);
}

Stampa (con gli indirizzi simbolici) Il ptr pX all'ind 0x03F8 vale 0x03FC. Sul mio computer: Il ptr pX all'ind 000000C7033FFD40 vale 000000C7033FFD4C. Le due cose stampate sono diverse: &pX è il numero civico del biglietto, pX è l'indirizzo scritto sul biglietto.

Negli schemi il contenuto di un puntatore si disegna spesso con una freccia dalla casella di pX alla casella di x: da qui il nome, il puntatore «punta» a x.

Un puntatore passato a scanf (slide 33–35)

scanf vuole un indirizzo. Un puntatore contiene un indirizzo: quindi si può passare il puntatore, senza &.

#include <stdio.h>

int main(void) {
    int x;
    int* pX = &x;
    printf("Inserisci un intero: ");
    scanf("%d", pX);
    printf("La var x all'ind %p vale %d \n", pX, x);
}

pX = &x si può fare anche se x non ha ancora un valore: serve il suo indirizzo, che esiste già. scanf riceve 0x03FC e scrive lì il numero: scrivendo 5, x vale 5.

Due errori del compilatore (slide 36–37)

Usare una variabile prima di dichiararla. Il C legge dall'alto in basso: alla riga int* pX = &x; la variabile x non esiste ancora.

pointer_ex1.c:4:16: error: 'x' undeclared (first use in this function)
    4 |     int* pX = &x;
      |                ^

Tipi che non corrispondono. Con float x = 5.0; l'espressione &x è un float*, e non va in un int*:

float x = 5.0;
int* pX = &x;

Nelle slide gcc dà un avviso (warning). gcc 16.1 dà un errore, anche senza -Wall e senza -Werror: dalla versione 14 questo controllo è diventato un errore.

pointer_ex2.c:3:15: error: initialization of 'int *' from incompatible pointer type 'float *' [-Wincompatible-pointer-types]
    3 |     int* pX = &x;
      |               ^

Ha senso: un int* promette che all'indirizzo c'è un intero. Se ci fosse un float, i bit verrebbero letti con la regola sbagliata (lezione 02B: il tipo dice come leggere i bit).

Hai il biglietto con l'indirizzo. Per vedere chi abita là, o per cambiarlo, devi andarci. È quello che fa l'operatore * davanti a un puntatore.

Come si legge. *pX si legge «la variabile puntata da pX», o «star pi ics». Non è una copia di x: è la stessa casella. «Unario» vuol dire che lavora su una cosa sola, quella alla sua destra.

*pX si può usare in due modi (slide 40):

Il programma delle slide 41–42

#include <stdio.h>

int main(void) {
    int x = 5;
    int *pX = &x;

    printf("x = %d\n", x);
    printf("*pX = %d\n", *pX);
    *pX = 10;
    printf("x = %d\n", x);
}

Nella riga *pX = 10; il programma legge l'indirizzo in pX, cioè 0x03FC, e scrive 10 in quella casella. pX non cambia; cambia x, senza che il suo nome compaia nella riga.

Rileggere scanf (slide 43–46)

Adesso la & di scanf ha un nome preciso. La documentazione di scanf chiede, per ogni conversione, un puntatore al tipo giusto: per %d serve un int*. Con int x, l'espressione &x è proprio un int*, ed è lì che scanf scrive. Per questo funzionano tutte e due le forme:

scanf("%d", &x);   // l'indirizzo calcolato al momento
scanf("%d", pX);   // l'indirizzo conservato in pX

Nel programma delle slide 44–46, con int x = 5; e int* pX = &x;, si scrive 1234: dopo scanf("%d", pX); il programma stampa La var x vale 1234.

Una persona può avere più nomi: il nome di battesimo, un soprannome, «il vicino del terzo piano». Sono alias: modi diversi per indicare la stessa persona. Con i puntatori succede lo stesso a una variabile.

#include <stdio.h>

int main(void) {
    int x = 5;
    int* pX = &x;
    int* pXbis = pX;
    *pXbis = 1234;
    printf("x = %d\n", x);
    printf("*pX = %d\n", *pX);
    printf("*pXbis = %d\n", *pXbis);
}

int* pXbis = pX; copia in pXbis l'indirizzo scritto in pX: due biglietti con lo stesso indirizzo. Poi *pXbis = 1234; va a quell'indirizzo e scrive 1234.

Stampa x = 1234, *pX = 1234, *pXbis = 1234: provato.

Come si legge. x, *pX e *pXbis sono tre nomi della stessa casella. pX e pXbis invece sono due variabili diverse, ognuna con il suo indirizzo, che contengono lo stesso numero. Per questo scanf("%d", &x);, scanf("%d", pX); e scanf("%d", pXbis); fanno esattamente la stessa cosa (slide 50).

Un biglietto bianco, o con un indirizzo inventato, non porta da nessuna parte. È il caso di un puntatore non inizializzato:

int* pX;     // non inizializzato
*pX = 10;    // ERRORE

Dopo la dichiarazione pX contiene un valore indeterminato, «?», come ogni variabile locale. Usato come indirizzo porta in un punto a caso della memoria. Con -Wall -Werror gcc 16.1 lo ferma:

non_init.c:3:9: error: 'pX' is used uninitialized [-Werror=uninitialized]
    3 |     *pX = 10;
      |     ~~~~^~~~

Il puntatore nullo

Per dire «questo puntatore non punta a niente» c'è un valore apposta: NULL.

Come si legge. NULL è il biglietto con scritto «nessun indirizzo». Serve a due cose:

• inizializzare un puntatore senza lasciarlo «?»: int *p = NULL;;
• riconoscere il caso «non punta a niente», confrontando il puntatore con NULL (con l'if, più avanti).

Ma NULL non è un indirizzo a cui andare:

int *p = NULL;   // inizializzazione sicura
*p = 10;         // ERRORE: comportamento indefinito

Questo programma compila anche con -Wall -Werror: il compilatore non se ne accorge. Quando lo esegui, di solito il programma viene fermato dal sistema operativo. Su Linux compare Segmentation fault. Per questo non l'ho lanciato: su Windows un programma che va in crash può aprire una finestra di errore.

Tre fatti per chiudere: quanto spazio occupa un puntatore, come si combinano & e *, e i tanti mestieri dell'asterisco.

Quanto è grande un puntatore (slide 54)

Un puntatore contiene un indirizzo, e gli indirizzi hanno sempre la stessa lunghezza su una data macchina, qualunque cosa ci sia a quell'indirizzo. Provato sul mio computer a 64 bit:

sizeof(x) 4 B
sizeof(pX) 8 B
sizeof(c) 1 B, sizeof(pC) 8 B
sizeof(d) 8 B, sizeof(pD) 8 B

int, char e double occupano 4, 1 e 8 byte; i puntatori a loro sempre 8. La dimensione di T* dipende dalla piattaforma, non da T: tipicamente 8 byte su una CPU a 64 bit e 4 byte su una a 32 bit.

& e * si annullano (slide 55)

& va dalla casella al suo indirizzo; * va dall'indirizzo alla casella. Uno dopo l'altro si annullano:

• *&a è a: prendi l'indirizzo di a e ci vai;
• &*pA è pA: vai alla casella puntata e ne prendi l'indirizzo.

Il programma della slide 55 lo mostra stampando lo stesso indirizzo quattro volte: &a, pA, &*pA e *&pA. Sul mio computer erano tutti 000000C2FEDFFC3C.

I quattro usi del simbolo * (slide 56)

Il trucco per non confonderli: se * sta tra due valori è una moltiplicazione; se sta dopo un tipo in una dichiarazione è parte del tipo; se sta davanti a un puntatore in un'espressione è il dereferenziamento.

L'esame di Programmazione I è al PC, unico per i tre canali: appelli lunedì 25/01/2027 e giovedì 11/02/2027. Da questa lezione in poi i puntatori ci sono sempre.

Esercizi sullo stato della memoria. Si chiede il valore di ogni variabile dopo una sequenza di istruzioni. Con i puntatori la regola in più è una: nella casella di un puntatore si scrive un indirizzo, e *p legge o scrive nella casella che sta a quell'indirizzo. Più avanti lo stesso schema avrà una parte per le chiamate di funzione e una per la memoria chiesta con malloc. Nel 2025/26, nel canale C, l'esercizio era proprio sullo stack e sullo heap.

Esercizi di programmazione. Le funzioni d'esame a volte restituiscono un secondo risultato attraverso un puntatore (scheda del corso): è proprio *p = valore; dentro una funzione, che vedrai con le funzioni. Gli errori che costano:

1. dimenticare la & in scanf: con -Wall -Werror non compila;
2. usare *p con p non inizializzato: non compila se il compilatore se ne accorge, altrimenti crash;
3. tipi di puntatore diversi (int* con un float): con gcc 16.1 non compila nemmeno senza opzioni;
4. stampare indirizzi quando l'esercizio chiede valori: CodeRunner confronta il testo, e gli indirizzi cambiano a ogni esecuzione.

Indirizzo

Il numero che indica la posizione di una variabile in memoria, di solito scritto in esadecimale.

Referenziamento

L'operazione &x, che dà l'indirizzo della variabile x.

%p

Lo specificatore di printf per stampare un indirizzo.

scanf

Funzione che legge dati da tastiera secondo un formato e li scrive agli indirizzi ricevuti; restituisce quanti valori ha letto.

Valore di ritorno di scanf

Il numero di valori letti con successo: può essere minore di quelli chiesti se l'input non va bene.

Puntatore

Una variabile che contiene l'indirizzo di un'altra variabile, detta variabile puntata.

Tipo puntatore T*

Il tipo delle variabili che contengono indirizzi di variabili di tipo T.

Dereferenziamento

L'operazione *p, che accede alla variabile all'indirizzo contenuto in p.

Alias

Un altro modo di raggiungere la stessa variabile, per esempio *p quando p contiene il suo indirizzo.

Aliasing

Il fatto che una variabile sia raggiungibile con più alias.

Puntatore non inizializzato

Un puntatore che contiene un valore indeterminato: non si può dereferenziare.

NULL

Il valore di puntatore che vuol dire «non punta a nessuna variabile».

Comportamento indefinito

Una situazione in cui il C non garantisce niente, per esempio leggere una variabile mai scritta o dereferenziare NULL.

lvalue

Qualcosa che ha un posto in memoria e può stare a sinistra di =; & si applica solo agli lvalue.

Spunta quando sai fare la cosa senza guardare gli appunti. Le spunte restano salvate in questo browser.

• So spiegare la differenza tra x e &x e stampare un indirizzo con %p.
• So leggere uno o più interi con scanf e spiegare perché serve la &.
• So che cosa restituisce scanf e che cosa succede con input come 12.5 o A.
• So dichiarare un puntatore del tipo giusto e assegnargli l'indirizzo di una variabile.
• So usare *p per leggere e per scrivere la variabile puntata.
• So disegnare lo stato della memoria con i puntatori, scrivendo gli indirizzi nelle loro caselle.
• So riconoscere gli alias e prevedere che cosa cambia scrivendo attraverso un puntatore.
• So perché non si può usare * su un puntatore non inizializzato o NULL.
• So quanto occupa un puntatore e che & e * si annullano.
• So distinguere i quattro usi del simbolo * dalla posizione.