Memoria e variabili, assegnamento ed espressioni

In memoria ci sono solo bit. Prendi questi 8 bit:

0100 0001

Che cosa sono? Dipende da come li leggi:

• come numero intero sono 65 (64 + 1, ricordi la base 2 della lezione 02 di Fondamenti);
• come carattere sono la lettera A, perché nel codice ASCII la A ha il numero 65;
• come pezzo di un numero più lungo non vogliono dire niente da soli.

I bit da soli non bastano: serve una regola per leggerli. Questa regola è il tipo. Le slide lo dicono così: un tipo è un ponte tra i bit e il senso che vogliamo dare ai dati.

Un tipo del C stabilisce sei cose (slide 3):

La rappresentazione dei bit (complemento a 2, IEEE 754) la studi in Fondamenti dell'Informatica (lezione 03) e in Architettura degli Elaboratori. Qui ti basta sapere che esiste.

Nella macchina di Von Neumann della lezione 02A le istruzioni lavoravano sugli indirizzi: LOAD, R0, @400. Programmare così vuol dire ricordarsi a memoria che all'indirizzo 400 c'è il prezzo e al 404 la quantità. I linguaggi di alto livello danno un nome a quelle caselle: invece di «la casella 400» scrivi prezzo. Questo nome con il suo tipo è una variabile.

Pensa a un cassetto di una cassettiera:

• sull'etichetta c'è scritto il nome;
• la forma del cassetto dice che cosa ci può stare: è il tipo;
• la posizione del cassetto nella cassettiera è l'indirizzo;
• quello che c'è dentro adesso è il valore, e può cambiare.

Come si legge. Una variabile è una casella di memoria a cui dai un nome. Il tipo dice quanti byte occupa e come leggerli. Il valore è quello che c'è dentro in questo momento.

L'esempio della slide 5:

int contatore = 1;
float media = 60.54;

Gli indirizzi si scrivono di solito in esadecimale, con il prefisso 0x (lezione 01 di Fondamenti). Quelli della tabella sono inventati: l'indirizzo vero lo decidono il compilatore e il sistema quando il programma parte, e cambia da un'esecuzione all'altra. Il programmatore non lo sceglie: sceglie il tipo, cioè quali valori può contenere la variabile, come sono codificati, quali operazioni si possono fare e come interagisce con altri tipi (slide 6).

La slide 7 mostra la famiglia completa dei tipi del C:

• tipi primitivi (già pronti nel linguaggio): interi, naturali (senza segno), reali;
• tipi derivati, costruiti da altri: puntatori, array, struct, union, enum, funzioni;
• void, il tipo «vuoto»;
• typedef, per dare un nome nuovo a un tipo;
• qualificatori come const, che si aggiungono a un tipo.

Per ora ne bastano pochi (slide 8):

La slide 12 li raggruppa per uso: numeri naturali (le versioni unsigned), interi (short, int, long, long long), reali (float, double), dimensioni (size_t, ptrdiff_t), caratteri e byte (char, unsigned char), logico (bool).

I numeri del C sono finiti (slide 9)

Gli insiemi della matematica $\mathbb{N}$, $\mathbb{Z}$ e $\mathbb{R}$ sono infiniti. Una variabile occupa un numero fisso di byte, quindi un tipo può contenere solo un numero finito di valori.

Un int occupa di solito 4 byte, cioè 32 bit: le combinazioni possibili sono $2^{32}$, circa 4,3 miliardi. Metà vanno ai negativi e metà allo zero e ai positivi:

Un unsigned int usa gli stessi 32 bit solo per lo zero e i positivi: da 0 a $2^{32}-1=4294967295$.

Per i reali il limite è un altro: float e double hanno un numero limitato di cifre, quindi molti numeri vengono approssimati. La lezione 03 di Fondamenti mostra come funziona la virgola mobile.

Prima di usare una casella bisogna chiederla, dicendo il nome e il tipo:

int x;

Questa riga è una dichiarazione: dice al compilatore che esiste una variabile di nome x e di tipo int. Quando il programma arriva a questa riga, riserva lo spazio per un int (4 byte) in una zona della memoria chiamata pila o stack. Da quel momento puoi usare la casella con il nome x.

Il nome x esiste solo nel sorgente C. Nell'assembly della lezione 02A non ci sono nomi: il compilatore trasforma ogni nome in un indirizzo. Per questo le slide dicono che l'identificatore è simbolico.

La prima cosa che si fa con una variabile è guardarne il valore.

int x = 10;          // variabile intera
float y = 3.14f;     // variabile reale (in virgola mobile)
printf("La variabile x vale: %d\n", x);   // %d → int
printf("La variabile y vale: %f\n", y);   // %f → float

Stampa:

La variabile x vale: 10
La variabile y vale: 3.140000

printf riceve prima una stringa di formato, poi i valori da stampare, separati da virgole. Dentro la stringa:

• il testo normale viene stampato così com'è;
• ogni specificatore di formato (%d, %f, …) è un posto da riempire: il primo specificatore prende il primo valore dopo la stringa, il secondo il secondo, e così via.

printf("x vale %d, y vale %d\n", x, y);

Il primo %d stampa x, il secondo %d stampa y (slide 37).

%f stampa sei cifre dopo la virgola: per questo 3.14 diventa 3.140000. La f in fondo a 3.14f dice che la costante è un float; senza, 3.14 sarebbe un double.

Larghezza e zeri (slide 38)

Risultati provati con gcc 16.1. Tutti i formati sono nel manuale della libreria GNU C (link nella slide 38 e nelle fonti).

error: format '%f' expects argument of type 'double', but argument 2 has type 'int' [-Werror=format=]

Il C non fissa la dimensione esatta dei tipi, perché deve funzionare su macchine molto diverse, dai microcontrollori ai server. Fissa solo un ordine:

sizeof è un operatore che dice quanti byte occupa un tipo o una variabile. Il risultato ha tipo size_t, e si stampa con %zu:

printf("int occupa %zu byte\n", sizeof(int));

Le slide 14–15 danno una tabella di riferimento per le macchine a 32 e 64 bit, con intervalli e specificatori. Le righe principali:

La slide 15 dice esplicitamente: non serve impararle a memoria. Servono gli specificatori più usati (%d, %u, %f, %c, %zu) e l'idea che ogni tipo ha un intervallo.

Le regole per gli identificatori (lezione 02A):

• possono contenere lettere, cifre e trattino basso _;
• devono cominciare con una lettera o con _ (di solito una lettera minuscola);
• niente spazi né simboli speciali;
• devono essere unici nel loro ambito: due variabili nello stesso blocco non possono avere lo stesso nome.

Esempio della slide 16: int laMiaPrimaVariabile;.

Oltre alle regole ci sono le convenzioni del corso (slide 17):

• tutto minuscolo, oppure camelCase per i nomi di più parole: sommaTot, media7giorni, elementoTrovato (la prima parola minuscola, le altre con l'iniziale maiuscola);
• nomi che dicono il ruolo del dato: somma, media, massimoTrovato;
• nomi corti come s, m, flag solo quando il senso è chiaro dal contesto;
• mai nomi senza senso come pippo o nonSoCheNomeDare.

Il nome non è un dettaglio: un buon nome rende il codice leggibile, riduce gli errori e aiuta a ragionare. All'esame il codice viene anche letto da un docente.

error: invalid suffix 'x' on integer constant

Una variabile ha due proprietà in più, legate a dove e quando esiste.

La visibilità (scope) dice in quale parte del codice puoi usare il nome:

• locale (o automatica, il caso normale): dichiarata dentro una funzione o un blocco { … }, si usa solo lì dentro;
• globale: dichiarata fuori da tutte le funzioni, si vede in tutto il file (e in altri file, se dichiarata extern);
• statica: con static, conserva il valore tra una chiamata e l'altra ma resta visibile solo nel suo blocco.

La durata (lifetime) dice per quanto tempo la variabile occupa memoria:

• le variabili locali stanno sullo stack e spariscono quando finisce il blocco;
• le variabili globali e statiche esistono per tutto il programma;
• le variabili dinamiche stanno in un'altra zona, lo heap: le crei tu con malloc() e restano finché non le liberi (più avanti nel corso).

Per capire il C bisogna sapere come la memoria viene presa e restituita. Il corso usa per questo un modello della memoria, che vedi nella prossima sezione.

Negli esercizi d'esame sullo stato della memoria si disegna la memoria di un programma riga per riga. Il modello è questo.

Area codice e area dati (slide 19–21)

Quando lanci un programma, il sistema lo carica dal disco in memoria centrale e gli riserva una zona divisa in due:

• l'area codice, con le istruzioni del programma: ha una dimensione fissa;
• l'area dati, con le variabili: può crescere, ma fino a un massimo.

Le variabili vengono messe nell'area dati una dopo l'altra, nell'ordine in cui sono dichiarate. Nel disegno ogni riga è una parola di 32 bit (4 byte).

Tre indirizzi speciali (slide 22)

Tre registri della CPU tengono il segno di dove si è arrivati:

All'inizio, prima di qualunque dichiarazione, FP e SP coincidono.

Lo stack cresce verso il basso (slide 23–24)

La parte dell'area dati che contiene le variabili si chiama stack (pila). Nel modello si disegna in alto e cresce verso gli indirizzi più bassi: ogni nuova variabile va sotto la precedente.

È come una pila di piatti appesa al soffitto: ogni piatto nuovo si aggiunge sotto. Quando dichiari int x;, SP scende di 4 byte (la dimensione di un int) e la casella tra il vecchio e il nuovo SP diventa x.

Se le variabili sono troppe e lo spazio dello stack finisce, il programma si interrompe con un errore a runtime di tipo stack overflow (slide 24).

Il valore iniziale è «?» (slide 25)

int main(void) {
    int x;
}

Dopo int x; lo spazio è riservato, ma nessuno ci ha scritto: dentro c'è quello che era rimasto in quei byte da prima. Il valore è indeterminato, e negli schemi si scrive «?».

Ho provato a stamparlo:

#include <stdio.h>
int main(void) {
    int x;
    printf("x vale %d\n", x);
    return 0;
}

Senza -Werror gcc avvisa (warning: 'x' is used uninitialized) e il programma stampa un numero a caso, sul mio PC x vale 32758. Con -Wall -Werror non compila:

error: 'x' is used uninitialized [-Werror=uninitialized]

Più variabili (slide 26)

int main(void) {
    int x;
    int y;
    int z;
}

Tre int da 4 byte: 12 byte, nell'ordine di dichiarazione. Lo stato dopo l'ultima dichiarazione:

(In alto gli indirizzi più grandi: la riga di x è la prima sotto FP, e SP è sceso di 12 byte.)

Una casella con «?» non serve a molto. Per metterci un valore si usa l'operatore =:

int x;
x = 10;

Oppure tutto in una riga, dichiarazione e primo valore insieme: è una definizione con inizializzazione.

int x = 10;

Come funziona (slide 29)

La forma generale è:

variabile = espressione;

Si esegue in tre passi:

1. si calcola l'espressione a destra (in gergo: viene valutata);
2. il calcolo produce un valore;
3. il valore viene copiato nella casella della variabile a sinistra; quello che c'era prima va perso.

I due lati hanno nomi tecnici:

• il lato sinistro è l'lvalue (da left value): deve indicare una casella di memoria, cioè una variabile;
• il lato destro è l'rvalue (right value): un valore o un'espressione da calcolare.

Per questo x = x + 1 ha senso in C: prima si calcola x + 1 con il valore vecchio, poi il risultato va in x. Non è un'equazione, è un ordine: «metti in x il valore di x + 1». E per questo 10 = x non compila: 10 non è una casella.

Quando il valore non ci sta (slide 28)

L'assegnamento deve rispettare il tipo. Tre casi:

Ho compilato gli ultimi due con gcc 16.1 e -Wall -Werror: compilano tutti e due senza nessun avviso, e stampano esattamente quello che dicono le slide. Il compilatore non ti protegge: le slide parlano di overflow «non rilevabili dal compilatore».

• Nel primo caso il numero 2 147 483 649 è $2^{31}+1$: per entrare in 32 bit «gira» come il contachilometri e diventa $-2^{31}+1=-2147483647$.
• Nel secondo 8.89 diventa 8: la virgola viene troncata, non arrotondata (anche 8.99 diventerebbe 8).

Per ora solo espressioni con variabili intere. Gli operatori:

Esempi della slide 30:

int incasso = biglietti * prezzoBiglietto;
int utile = incasso - costoSala;

Divisione intera e resto (slide 32)

Dividere 13 caramelle in 3 sacchetti uguali: in ogni sacchetto ne vanno 4 e ne avanza 1.

int a = 13, b = 3;
int quot = a / b;    // 4
int r = a % b;       // 1, perche' 13 = 3*4 + 1

• / tra due interi dà solo la parte intera del quoziente. La parte decimale viene scartata, non arrotondata: 7 / 2 fa 3, non 3,5 e non 4.
• % dà il resto: quello che avanza.

Il resto serve molto per la parità: se n % 2 vale 0 il numero è pari, se vale 1 è dispari (per n positivo o zero).

Chi viene prima (slide 31)

Quando un'espressione ha più operatori, contano le precedenze:

1. le parentesi ( ) prima di tutto, anche annidate;
2. poi *, /, %;
3. poi + e -;
4. a parità di livello, da sinistra a destra;
5. l'assegnamento = per ultimo.

Risultati provati. L'ultima riga mostra che con gli interi 7 / 2 * 2 non torna 7: la divisione ha già perso il resto.

Il programma «treVariabili» delle slide, eseguito riga per riga:

#include <stdio.h>

int main(void) {
    int x;
    int y;
    int z;
    x = 5;
    y = 2;
    z = x + y;
    printf("Le var x, y  e z valgono %d, %d, %d\n", x, y, z);
}

Nella slide 35 la riga z = x + y; è affiancata dalle istruzioni assembly che fa davvero la macchina, come nella lezione 02A:

LOAD,  R0, @x      ; copia x in un registro
LOAD,  R1, @y      ; copia y in un altro registro
ADD,   R0, R1      ; somma nei registri
STORE, R0, @z      ; scrive il risultato nella casella di z

Una riga di C diventa quattro istruzioni macchina. Il nome x è diventato l'indirizzo @x.

La slide 39 riassume i quattro modi di mettere un valore in una variabile:

L'assegnamento multiplo funziona perché un assegnamento è anche un'espressione che vale il valore assegnato: c = 0 vale 0, e quel valore va in b, e così via.

Assegnamenti composti (slide 40)

Capita spesso di aggiornare una variabile partendo dal suo valore: somma = somma + voto. Il C ha una scorciatoia:

Risultati provati.

Più uno e meno uno (slide 41)

x++;    // come x = x + 1
x--;    // come x = x - 1

Servono ogni volta che si conta: i contatori dei cicli, che arriveranno presto. Le slide li usano solo come istruzioni a sé, su una riga da soli. Dentro un'espressione più grande (y = x++ * 2) hanno un comportamento più sottile, che il corso non tratta: non usarli così.

L'esame di Programmazione I è al PC, unico per i tre canali: appelli lunedì 25/01/2027 e giovedì 11/02/2027. Questa lezione entra in due tipi di esercizio.

Esercizi sullo stato della memoria. Nel 2025/26 erano uno dei due esercizi di teoria del canale C (scheda del corso). Si chiede il valore delle variabili dopo una sequenza di istruzioni, che cosa viene stampato, quali caselle sono ancora «?». Il metodo è quello della sezione «Un programma seguito nella memoria»: una colonna per variabile, una riga per istruzione. Più avanti nel corso lo stesso schema si allarga alle chiamate di funzione, con un frame per ogni chiamata.

Esercizi di programmazione. Ogni programma usa variabili, assegnamenti, printf. Gli errori che costano:

1. specificatore sbagliato in printf (%f per un int): con -Wall -Werror il programma non compila;
2. variabile usata prima di darle un valore: non compila con -Werror, e se compilasse darebbe valori a caso;
3. divisione intera dove serviva quella con la virgola (7 / 2 fa 3);
4. overflow con numeri grandi: il compilatore non avvisa;
5. stampe diverse da quelle richieste: CodeRunner confronta il testo carattere per carattere, spazi compresi.

Tipo

Regola che dà significato ai bit: dimensione, valori ammessi, operazioni, rappresentazione, conversioni.

Variabile

Nome e tipo associati a una porzione di memoria che contiene un valore.

Indirizzo

Posizione in memoria di una variabile; lo decide il sistema, spesso scritto in esadecimale (0x…).

Dichiarazione

Riga che introduce una variabile con tipo e nome, per esempio int x;.

Inizializzazione

Primo valore dato a una variabile nella dichiarazione: int x = 10;.

Assegnamento

variabile = espressione;: calcola la destra e copia il valore nella variabile.

lvalue / rvalue

Lato sinistro (una casella di memoria) e lato destro (un valore da calcolare) di un assegnamento.

Overflow

Valore che non sta nel tipo: un int oltre il massimo «gira» verso i negativi.

Stack (pila)

Zona dell'area dati dove stanno le variabili locali; nel modello del corso cresce verso il basso.

Heap

Zona della memoria per le variabili dinamiche, create con malloc e liberate a mano.

Program counter (PC)

Registro con l'indirizzo dell'istruzione da eseguire.

Frame pointer (FP)

Indirizzo da cui partono le variabili della funzione in esecuzione (per ora main).

Stack pointer (SP)

Indirizzo in cui verrà messa la prossima variabile.

Stack overflow

Errore a runtime: lo spazio dello stack è finito.

Valore indeterminato («?»)

Contenuto di una variabile locale dichiarata e mai assegnata.

sizeof

Operatore che dà i byte occupati da un tipo o da una variabile; il risultato è un size_t.

size_t

Tipo intero senza segno per dimensioni e conteggi, da stddef.h; si stampa con %zu.

Specificatore di formato

Codice come %d o %f in printf che indica dove e come stampare un valore.

Divisione intera

/ tra interi: tiene solo la parte intera del quoziente.

Modulo

%: il resto della divisione intera.

Precedenza

Regola che dice quale operatore si calcola prima.

camelCase

Convenzione per i nomi composti: sommaTot, elementoTrovato.

Visibilità (scope)

Parte del codice in cui si può usare un nome.

Durata (lifetime)

Tempo in cui una variabile occupa memoria.

Assegnamento composto

x += y e simili: aggiorna una variabile con un'operazione.

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

• So dire che cos'è un tipo e quali sei cose stabilisce.
• So elencare nome, tipo, indirizzo e valore di una variabile e chi li sceglie.
• So spiegare perché int, unsigned int e float sono finiti e qual è l'intervallo di un int a 32 bit.
• So usare sizeof e stamparlo con %zu, e so che il C garantisce solo l'ordine tra le dimensioni.
• So scegliere un nome valido e leggibile in camelCase.
• So distinguere visibilità e durata, e variabili locali, globali, statiche e dinamiche.
• So disegnare area codice, area dati, PC, FP e SP e mettere le variabili sullo stack in ordine di dichiarazione.
• So che una variabile locale non inizializzata vale «?» e che gcc con -Werror non compila se la uso.
• So eseguire un assegnamento: prima la destra, poi la copia a sinistra.
• So prevedere overflow e troncamento negli assegnamenti, anche se gcc non avvisa.
• So calcolare espressioni intere con /, % e le precedenze.
• So usare printf con %d, %f, %6d, %06d.
• So usare +=, -=, *=, /=, %=, ++ e --.
• So seguire un programma riga per riga scrivendo lo stato della memoria.