Lezione 03 di Programmazione 1, 11 settembre 2026. Slide: 2.2 Introduzione al C, slide 1-56 e 64-65. Prima: Architettura hardware e software di un calcolatore. Dopo: Espressioni, operatori e costanti, che copre il resto del deck (slide 57-76: espressioni, precedenze, ++ e --, costanti, caratteri e ASCII).
Il filo della lezione:
linguaggio di programmazione sintassi (forma) + semantica (significato)
|
v
livelli di astrazione linguaggio macchina -> assembly -> C
|
v
compilare o interpretare il C si compila
|
v
macchina astratta C memoria a celle, standard input e output
|
v
dal sorgente all'eseguibile editor -> preprocessore -> compilatore -> linker -> loader
|
v
lessico case sensitive, spazi, commenti, identificatori, keyword
|
v
struttura di un programma main { istruzioni; }
|
v
variabili nome, tipo, l-value (dove), r-value (cosa)
|
v
assegnazione valuta a destra, scrivi a sinistra
1Concetti
1.1Linguaggio di programmazione
Un algoritmo scritto in linguaggio naturale (“se sono le 7 accendi la sveglia”) il computer non lo capisce: va tradotto in un linguaggio che l’esecutore sa eseguire (slide 2-3). La sequenza di istruzioni in quel linguaggio è il programma. L’italiano è ambiguo (“ho visto un uomo con il binocolo”: chi ha il binocolo?), un linguaggio di programmazione non può permetterselo. Per questo è definito in modo preciso su due piani separati.
L’analogia con l’italiano: “il gatto mangia il topo” e “il topo è mangiato dal gatto” sono frasi diverse, entrambe grammaticali, con lo stesso significato. “gatto il topo mangia il” non è grammaticale. “il topo mangia la montagna” è grammaticale ma non ha senso.
Le due cose sono indipendenti, e in C succede lo stesso:
x = x + 1;ex = 1 + x;sono stringhe diverse, entrambe sintatticamente corrette, e hanno la stessa semantica: aumentano di uno. È la domanda della slide 3 (“I1 ha lo stesso significato di I2?”).x=x+1;ex = x + 1;differiscono solo negli spazi: per il compilatore sono la stessa stringa di simboli (gli spazi si ignorano, vedi Lessico).x = x + 1senza punto e virgola ha un errore di sintassi: il compilatore lo rifiuta e non produce nessun eseguibile.media = somma / 0;è sintatticamente corretta ma semanticamente sbagliata: si compila (gcc avvisa soltanto), e il problema esce quando la esegui.
Come si riconosce il tipo di errore: se il compilatore si ferma e non produce l’eseguibile, è sintassi (o un nome non dichiarato, che il compilatore scopre allo stesso modo). Se il programma parte e fa la cosa sbagliata o si blocca, è semantica.
La grammatica completa del C sta nell’appendice E del libro di testo (slide 39).
1.2Livelli di astrazione
Fra il programmatore, che conosce il problema, e la macchina, che capisce solo circuiti a due valori (0 e 1), c’è il linguaggio di programmazione. Il suo livello di astrazione è una scelta (slide 4-6): troppo vicino alla macchina e programmare è difficile, troppo vicino al programmatore e i programmi diventano inefficienti.
La stessa istruzione, “il totale è la paga più gli straordinari”, a tre livelli (slide 6):
C TOT = PAGA + STRAORD; alto
|
assembly LOAD PAGA |
ADD STRAORD |
STORE TOT |
v
linguaggio 0100001111 basso
macchina 1100111001
0110001111
In assembly si vede il lavoro della CPU visto in Architettura hardware e software di un calcolatore: carica un valore nel registro, somma, salva in una cella. In C basta una riga, e i nomi TOT, PAGA, STRAORD sostituiscono gli indirizzi.
Organizzazione a strati (slide 5). Dal basso: hardware (CPU, disco, periferiche), sistema operativo (Linux, Windows, macOS), software di sistema (compilatore, debugger), ambienti di programmazione, software applicativo, software di produttività individuale (fogli elettronici, client di posta). Ogni strato usa quello sotto.
Realizzare un programma (slide 7) si può fare a tre livelli:
- hardware: si programmano direttamente circuiti e reti logiche, il linguaggio coincide con il codice macchina;
- firmware: microprogrammazione con un insieme comune di istruzioni in assembly (microistruzioni), livello basso;
- software: un linguaggio intermedio che simula le funzionalità della macchina fisica. Più flessibilità (si possono scrivere molti più programmi), meno efficienza (il linguaggio intermedio va tradotto).
Macchina fisica (slide 8). Una macchina fisica esegue istruzioni nel suo linguaggio, il codice macchina: linguaggio e macchina “esistono in simbiosi”. A una macchina corrisponde un linguaggio (il suo), ma un linguaggio in generale può essere eseguito da più macchine. Il cuore della macchina fisica è il ciclo fetch-decode-execute, che fa da interprete del codice macchina.
Cosa chiediamo a un linguaggio (slide 9):
- astrazione della memoria: riferirsi alle celle con nomi simbolici (
totale) invece che con indirizzi binari (0101010011110101); - astrazione delle istruzioni: scrivere operazioni complesse, come un’espressione aritmetica, in una forma leggibile;
- astrazione dell’algoritmo: poter esprimere direttamente sequenza, scelta e ripetizione.
1.3Il linguaggio C
(slide 14-17)
- Creato nel 1972 da Dennis Ritchie ai Bell Labs, evoluzione dei linguaggi BCPL e B. La slide 14 dice “inventato da Brian Kernighan e Dennis Ritchie”: è impreciso, il linguaggio è di Ritchie (la slide 16 lo dice giusto). Kernighan è coautore con Ritchie del libro di riferimento, The C Programming Language (1978, seconda edizione 1988, citato nella slide 15).
- Nato come linguaggio di sistema per scrivere Unix, oggi usato per sistemi operativi (Linux, Windows, macOS), compilatori, editor, e in generale ovunque serva efficienza. È general-purpose: non è legato a un dominio.
- Standard ANSI nel 1989 (C89, detto anche ANSI C), aggiornato nel 1999 (C99). Le slide si fermano qui, ma dopo sono usciti C11 (2011, quello che usiamo con
-std=c11), C17 (2018, solo correzioni) e C23 (2024). - Portabile: lo stesso codice si compila su macchine diverse (“hardware independent”, slide 17).
- Linguaggio di medio livello: più astratto dell’assembly, più vicino alla macchina di Pascal o Ada. Efficiente, ma a volte “troppo” vicino alla macchina.
| Livello | Linguaggi |
|---|---|
| alto | Ada, Pascal, BASIC |
| medio | C, FORTH |
| basso | assembly |
Il C++ (Stroustrup, Bell Labs) è un’evoluzione del C: aggiunge astrazione sui dati, programmazione a oggetti, la Standard Template Library e migliora alcuni costrutti del C. All’esame al calcolatore si scrive un C++ “alla C” (vedi Esami passati), quindi quello che si impara qui vale anche lì.
1.4Compilazione e interpretazione
Due modi di far eseguire a una macchina un programma scritto in un linguaggio che lei non capisce direttamente (slide 19). L’intuizione: un libro in inglese da far leggere a chi parla solo italiano. Si può farlo tradurre tutto una volta, e poi lo si legge quante volte si vuole (compilazione); oppure si può tenere accanto un interprete che traduce a voce una frase alla volta, ogni volta che lo si legge (interpretazione).
| Compilazione | Interpretazione | |
|---|---|---|
| cosa fa | traduce tutto il programma in un altro linguaggio (per esempio codice macchina), senza eseguirlo | esegue direttamente il codice sorgente, un’istruzione alla volta |
| esecuzione | veloce: la decodifica è già stata fatta | più lenta: ogni istruzione va decodificata mentre gira |
| costo | la traduzione può richiedere molto tempo | nessuna traduzione a parte |
| pro | efficienza, ottimizzazioni | flessibilità, portabilità, interattività (debug a run-time) |
| contro | poca flessibilità, si perde informazione sulla struttura del sorgente | scarsa efficienza |
Le righe “pro” e “contro” sono della slide 25. Lì la compilazione pura è detta anche “difficile, data la lontananza fra e ”, il linguaggio della macchina ospite: tradurre da un linguaggio ad alto livello al codice macchina è un salto grande.
Il C è un linguaggio compilato. Python, per confronto, è interpretato.
Due conseguenze pratiche, da tenere a mente per le domande SI/NO:
- un errore di sintassi in C blocca tutto il programma, anche le righe prima dell’errore non vengono eseguite, perché non esiste ancora un eseguibile. Un interprete invece esegue le righe giuste e si ferma quando arriva a quella sbagliata;
- l’eseguibile prodotto dal compilatore gira solo sulla macchina (e sul sistema operativo) per cui è stato tradotto. È il sorgente C a essere portabile, non l’eseguibile.
Macchina astratta (slide 21-23). Dato un linguaggio , la macchina astratta è un qualsiasi insieme di strutture dati e algoritmi capace di memorizzare ed eseguire programmi scritti in . È un’astrazione del calcolatore e delle sue risorse: memoria (dati e programma), controllo della sequenza, controllo dei dati, gestione della memoria, operazioni. Il componente essenziale è l’interprete:
start
|
v
+-> acquisisci la prossima istruzione
| |
| v
| decodifica
| |
| v
| acquisisci gli operandi
| |
| v
| seleziona l'operazione ---------------------+
| | | | |
| v v v v
| esegui OP1 esegui OP2 ... esegui OPn esegui HALT
| | | | |
| +----------+------------+ v
| | stop
| v
+-- memorizza il risultato
È lo stesso ciclo fetch-decode-execute della CPU, scritto per un linguaggio qualsiasi.
La macchina astratta C (slide 26). Il programma C non gira direttamente: il compilatore lo traduce nel linguaggio della macchina ospite , che poi lo esegue interpretandolo con il suo ciclo fetch-decode-execute. Quindi anche un linguaggio compilato, alla fine, passa da un interprete: quello hardware della CPU.
programma C --compilazione--> binario per Mo --interpretazione (CPU)--> esecuzione
1.5Dal sorgente all’eseguibile
(slide 27 e slide 29)
| Fase | Chi | Cosa succede |
|---|---|---|
| Edit | editor | scrivi il programma e lo salvi su disco (ciao.c) |
| Preprocess | preprocessore | elabora le direttive che iniziano con #: per esempio #include <stdio.h> viene sostituito dal contenuto del file. Il risultato è un sorgente “espanso” |
| Compile | compilatore | traduce il sorgente in codice oggetto (ciao.o) e lo salva su disco. Qui escono gli errori di sintassi e i nomi non dichiarati |
| Link | linker | collega il tuo codice oggetto con altro codice già disponibile, le librerie (per esempio quella che contiene il codice di printf), e produce l’eseguibile |
| Load | loader | carica l’eseguibile dal disco nella memoria centrale |
| Execute | CPU | prende un’istruzione alla volta e la esegue, eventualmente scrivendo nuovi valori in memoria |
Le prime quattro fasi producono file su disco; le ultime due avvengono in memoria centrale, ogni volta che lanci il programma.
Su Linux con gcc un solo comando fa preprocessore, compilazione (con l’assemblatore, che le slide non nominano a parte) e link. L’editing lo fai tu prima, il caricamento e l’esecuzione partono quando lanci il programma:
gcc -std=c11 -Wall -Wextra -Wpedantic ciao.c -o ciao
./ciao
-Wall -Wextra -Wpedantic accendono gli avvisi (warning): il compilatore segnala anche cose che si compilano ma sono probabilmente sbagliate. Un errore blocca la compilazione, un warning no: l’eseguibile viene prodotto lo stesso. Per questo i warning vanno letti, non ignorati: quasi tutti gli errori semantici di questa nota (variabile non inizializzata, & dimenticata in scanf, divisione per zero) gcc li segnala proprio come warning.
Esempi di quale fase si lamenta:
| Problema | Fase | Messaggio di gcc 16 |
|---|---|---|
manca #include <stdio.h> e usi printf | compilazione | implicit declaration of function 'printf' (errore) |
manca il ; | compilazione | expected ';' before 'return' |
scrivi Printf invece di printf | compilazione | implicit declaration of function 'Printf'; did you mean 'printf'? |
media = somma / 0; | nessuna: compila con un warning | a run-time il programma muore con Floating point exception |
1.6Struttura di un programma
(slide 40)
#include <stdio.h> direttive per il preprocessore
int main(int argc, char *argv[]) intestazione
{
istruzione; sequenza di istruzioni
istruzione; fra { e }, ognuna chiusa da ;
...
}
Un programma C è composto da:
- un’intestazione, con l’identificatore predefinito
mainseguito da(int argc, char *argv[]); - una sequenza di istruzioni racchiusa fra
{e}.
Le istruzioni sono le frasi del linguaggio, e ognuna termina con ;. main è il punto da cui parte l’esecuzione: il programma esegue le istruzioni del corpo dall’alto in basso, una dopo l’altra, e finisce alla }.
Pezzo per pezzo, sul primo programma delle slide (in Esempi svolti a lezione):
| Pezzo | Significato |
|---|---|
#include <stdio.h> | direttiva per il preprocessore: include la libreria di input/output standard, dove sono dichiarate printf e scanf |
int main(int argc, char *argv[]) | intestazione: main è il punto da cui parte l’esecuzione. argc e argv sono gli argomenti passati da riga di comando |
{ ... } | il corpo: la sequenza di istruzioni |
printf("Hello World!\n"); | stampa la stringa sullo standard output. \n è il carattere “a capo” |
; | chiude ogni istruzione |
Le due intestazioni. Compilato con -Wextra, gcc avvisa che argc e argv non sono usati (unused parameter 'argc'). Quando non servono si scrive l’intestazione senza parametri, int main(void). È quella usata nel codice di queste note; quella delle slide resta corretta.
return 0; dice al sistema operativo che il programma è terminato bene. Dal C99 arrivare alla } finale di main senza return equivale a return 0;, quindi il programma della slide è corretto; scriverlo esplicitamente resta buona pratica, ed è quello che fanno i programmi del prof nel deck 3.2. Un return 1; invece segnala un errore: lo useremo quando l’input non è valido.
Esempio minimo, poi uno con due istruzioni:
#include <stdio.h>
int main(void)
{
printf("Hello World!\n");
return 0;
}
#include <stdio.h>
int main(void)
{
printf("Prima riga\n");
printf("Seconda riga\n");
return 0;
}
Il secondo stampa Prima riga e poi Seconda riga, nell’ordine in cui sono scritte (verificato): le istruzioni si eseguono in sequenza.
1.7Lessico
Il lessico sono le regole sulle “parole” del linguaggio: quali caratteri contano, quali nomi si possono usare (slide 34-38).
Case sensitive. Il C distingue maiuscole e minuscole: Var1, var1 e VAR1 sono tre nomi diversi, quindi tre variabili diverse.
#include <stdio.h>
int main(void)
{
int var1 = 1;
int Var1 = 2;
int VAR1 = 3;
int _velocita = 40;
int velocita_massima = 130;
int xy23 = 23;
printf("%d %d %d\n", var1, Var1, VAR1);
printf("%d %d %d\n", _velocita, velocita_massima, xy23);
return 0;
}
Output (verificato):
1 2 3
40 130 23
Controesempio: Printf("ciao\n"); non compila. Per il C Printf è un nome sconosciuto, diverso da printf; gcc 16 dà errore implicit declaration of function 'Printf'; did you mean 'printf'?.
Spazi. Spazio, tab e a capo (newline) vengono ignorati, tranne dentro una stringa. Servono solo a rendere il codice leggibile. Queste due versioni sono lo stesso programma per il compilatore:
#include <stdio.h>
int main(void)
{
int x;
int myVar;
x=3;myVar=5;
printf("%d %d\n", x, myVar);
x = 3;
myVar = 5;
printf("%d %d\n", x, myVar);
printf("ciao mondo\n");
printf("ciaomondo\n");
return 0;
}
Output (verificato): 3 5 due volte, poi ciao mondo e ciaomondo. Le due assegnazioni scritte attaccate o separate danno lo stesso risultato; le due stringhe no, perché dentro le virgolette lo spazio è un carattere come gli altri.
Tabella ASCII. I caratteri sono memorizzati come numeri secondo la codifica ASCII: ogni carattere ha un codice. Il primo carattere della tabella, codice 0, è NUL, un carattere speciale che non si stampa. La tabella si vede per intero in Espressioni, operatori e costanti.
Commenti. Testo ignorato dal compilatore, per chi legge il codice.
/* ... */: commento a blocco, può occupare più righe;// ...: commento in linea, finisce a fine riga.
#include <stdio.h>
int main(void)
{
/* Questo e' un esempio
su due righe */
int x = 3; // commento in linea
printf("%d\n", x);
return 0;
}
Stampa 3 (verificato): i commenti spariscono prima della compilazione. Controesempio: un /* senza il suo */ “mangia” tutto il resto del file, e il compilatore dà errore unterminated comment.
Identificatori (slide 37, slide 48). Sono i nomi che il programmatore dà a variabili, funzioni e altri oggetti. Il motivo delle regole: il compilatore deve capire senza ambiguità dove finisce un nome e dove comincia un numero o un operatore. Regole:
- composti da lettere, cifre e underscore
_; - il primo carattere è una lettera o
_, mai una cifra; - diversi da tutte le parole chiave.
Le lettere sono quelle inglesi: niente accenti (velocità non va bene, per questo nelle slide è velocita_massima).
| Validi | Non validi |
|---|---|
a, x, alfa, pippo, a1, xy23 | 1a (inizia con una cifra: il compilatore lo legge come il numero 1 seguito da a) |
MyFriend, DopoDomani | a b (contiene uno spazio: sono due identificatori) |
velocita_massima, _velocita | int (parola chiave) |
Int (diverso da int) | dopo-domani (il - è un operatore: si legge dopo meno domani) |
Cosa dice davvero gcc su quelli non validi (verificato, questo codice non compila):
int 1a = 0; error: invalid suffix "a" on integer constant
int int = 0; error: two or more data types in declaration specifiers
int dopo-domani = 0; error: expected '=', ',', ';', ... before '-' token
int a b = 0; error: expected '=', ',', ';', ... before 'b'
Parole chiave (keyword). Parole riservate del linguaggio, con un significato fissato a priori: non si possono usare come identificatori anche se lessicalmente andrebbero bene. L’ANSI C del 1989 ne ha 32 (slide 38):
auto break case char const continue default do
double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while
Il numero 32 vale per il C89. Gli standard successivi ne hanno aggiunte: il C99 inline, restrict, _Bool, _Complex, _Imaginary; il C11 _Alignas, _Alignof, _Atomic, _Generic, _Noreturn, _Static_assert, _Thread_local; il C23 fra le altre bool, true, false, nullptr. Alcuni compilatori aggiungono estensioni proprie (la slide cita asm, far, near, pascal e altre). Se usi una keyword come nome, l’editor o il compilatore segnalano errore.
La slide 44 cita come esempio di parole chiave if, then, while: then in C non è una parola chiave (lo è in Pascal), e infatti non compare nell’elenco delle 32.
Nomi e variabili, una regola sola (slide 44). Per evitare ambiguità è vietato usare:
- lo stesso identificatore per variabili diverse (non sapremmo più quale si intende): due
int x;nello stesso blocco dannoerror: redefinition of 'x'; - identificatori diversi per la stessa variabile.
1.8Standard I/O e memoria
La macchina astratta C ha un’unità centrale che esegue il programma, una memoria centrale e due periferiche standard, tutte sul bus (slide 30-33). L’unità centrale esegue il programma usando i dati in memoria e parla con l’utente attraverso l’I/O.
bus di sistema
============================================================
| | | |
+---------+ +---------+ +----------+ +----------+
| unità | x ->| cella | | [][][][] | | [][][][] |
| centrale| a ->| cella | | standard | | standard |
+---------+ alfa->| cella | | input | | output |
| ... | | tastiera | | video |
+---------+ +----------+ +----------+
memoria centrale
Standard input e standard output. Il C astrae le periferiche. Ogni programma ha due periferiche standard:
- standard input (
stdin), di solito la tastiera; - standard output (
stdout), di solito lo schermo.
Si possono pensare come sequenze di celle, ognuna con un dato, da cui leggere (input) o in cui scrivere (output). Il vantaggio dell’astrazione: il programma non sa se l’input arriva dalla tastiera o da un file. Con ./prog < dati.txt lo standard input diventa il file, e il programma non cambia di una riga.
Memoria. La memoria della macchina astratta è divisa in celle elementari, le variabili. Ogni cella contiene un dato usato dal programma. Si guarda solo la memoria dati: dove sta il codice del programma per ora non interessa.
I dati possono essere:
- numeri;
- caratteri;
- stringhe, cioè successioni finite di caratteri in celle consecutive;
- composizioni arbitrarie delle precedenti.
Come viene gestita la memoria per ora non conta. Conta come ci si riferisce a queste celle: con gli identificatori.
1.9Istruzioni di input/output
Senza input e output un programma sarebbe inutile per l’utente: non potrebbe ricevere dati né mostrare risultati (slide 41-42).
| Istruzione | Direzione | Forma nelle slide |
|---|---|---|
scanf | legge dallo standard input e mette il dato in una variabile | scanf(<variabile>) |
printf | scrive sullo standard output il valore di un’espressione | printf(<espressione>) |
Entrambe stanno nella libreria stdio.h, che va inclusa con #include <stdio.h>.
La forma delle slide (scanf(&x);, printf((a-z)/10);) è semplificata per mostrare l’idea, e così non compila: gcc 16 dà errore su entrambe (passing argument 1 of 'scanf' from incompatible pointer type, passing argument 1 of 'printf' makes pointer from integer without a cast). In C vero il primo argomento è una stringa di formato, fra virgolette, che dice come leggere o scrivere il dato:
| Segnaposto | Tipo | Esempio |
|---|---|---|
%d | intero (int) | printf("%d\n", x); |
%c | carattere (char) | printf("%c\n", alt); |
In printf il testo della stringa di formato si stampa così com’è, e ogni %d viene sostituito dal valore dell’espressione corrispondente, nell’ordine: printf("a = %d, b = %d\n", 3, 4 + 1); stampa a = 3, b = 5.
Il & in scanf. Davanti alla variabile in scanf va &, che vuol dire “l’indirizzo di”. scanf deve sapere dove scrivere il dato letto, non quanto vale la variabile adesso: è il concetto di l-value qui sotto. printf invece ha bisogno solo del valore, quindi niente &.
Controesempio, scanf senza & (verificato, compila con un warning):
int x = 0;
scanf("%d", x); warning: format '%d' expects argument of type 'int *',
but argument 2 has type 'int'
scanf riceve il valore di x, cioè 0, e lo usa come indirizzo: prova a scrivere il numero letto nella cella di indirizzo 0. Il programma muore con Segmentation fault. Con un altro valore di x potrebbe scrivere in una cella a caso e andare avanti, che è peggio.
Il valore di ritorno di scanf. scanf restituisce quanti valori è riuscita a leggere e assegnare: 1 se ha letto il numero, 0 se l’input non è un numero (per esempio ciao), EOF se l’input è finito. Se non lo controlli e l’input è sbagliato, la variabile resta com’era, cioè senza valore, e il programma va avanti con quella. Il controllo si scrive con un if (spiegato in Istruzioni condizionali): “se scanf non ha letto 1 valore, stampa un messaggio e termina con return 1”.
Esempio 1, un valore letto e uno stampato:
#include <stdio.h>
int main(void)
{
int anni;
printf("Quanti anni hai? ");
if (scanf("%d", &anni) != 1) {
printf("non e' un numero\n");
return 1;
}
printf("Fra 10 anni ne avrai %d\n", anni + 10);
return 0;
}
Con input 19 stampa Quanti anni hai? Fra 10 anni ne avrai 29; con diciannove stampa Quanti anni hai? non e' un numero (verificato). Il messaggio di richiesta e la risposta stanno sulla stessa riga perché la prima printf non ha \n: quando scrivi tu da tastiera l’a capo lo metti premendo Invio.
Esempio 2, due valori letti con una sola scanf, due risultati:
#include <stdio.h>
int main(void)
{
int base;
int altezza;
printf("Base e altezza: ");
if (scanf("%d %d", &base, &altezza) != 2) {
printf("input non valido\n");
return 1;
}
printf("area = %d\n", base * altezza);
printf("perimetro = %d\n", 2 * (base + altezza));
return 0;
}
Con 4 3 stampa area = 12 e perimetro = 14; con 4 da solo o con 4 tre stampa input non valido (verificato). Qui il controllo è != 2 perché i valori da leggere sono due: scanf restituisce 1 se ne ha letto solo il primo.
1.10Variabili
Variabile in C e in matematica (slide 43-46). In matematica una variabile è un simbolo per un valore fissato, e x = x + 1 sarebbe una contraddizione (sottrai e ottieni ). In un linguaggio di programmazione una variabile è associata a una cella di memoria: un contenitore il cui valore può cambiare durante l’esecuzione. x = x + 1 vuol dire “prendi quello che c’è in , aggiungi 1, rimettilo in ”.
Le variabili sono denotate da identificatori, che servono a distinguerle. Il nome individua l’indirizzo della cella: è l’astrazione della memoria chiesta al linguaggio, il programmatore scrive x e il compilatore sa a quale indirizzo corrisponde.
nome l-value r-value
id -> [ cella @1008 ] -> 128
I nomi vengono dal lato dell’assegnazione in cui si usano: a sinistra di = serve un posto dove scrivere (l-value), a destra serve un valore da leggere (r-value). In x = x + 1; la stessa variabile compare due volte con due ruoli: la a destra fornisce il suo valore, la a sinistra fornisce la sua cella.
L’analogia: una casella postale ha un numero (l-value, dove sta) e una lettera dentro (r-value, cosa contiene). “Metti questa lettera nella casella 1008” usa il numero; “leggimi la lettera nella casella 1008” usa il contenuto.
Esempi graduati per riconoscere i due ruoli:
| Istruzione | x usata come | y usata come |
|---|---|---|
x = 5; | l-value (scrivo in x) | |
y = x; | r-value (leggo x) | l-value |
x = x * y; | a sinistra l-value, a destra r-value | r-value |
scanf("%d", &x); | l-value (&x è l’indirizzo) | |
printf("%d", x + y); | r-value | r-value |
Controesempio: una costante come 5 o un’espressione come x + 1 ha solo un r-value. Non c’è una cella dietro, quindi non può stare a sinistra di = (vedi Assegnazione).
1.11Dichiarazione
Prima di usare una variabile la si dichiara (slide 49-50). Quando il compilatore incontra la dichiarazione, predispone un’area di memoria grande abbastanza per il tipo scelto. Senza dichiarazione il compilatore non sa né quanto spazio riservare né come interpretare i bit.
tipo identificatore;
tipo identificatore = espressione;
Nella notazione delle slide la seconda forma si scrive tipo identificatore [= espressione];: le parentesi quadre indicano una parte facoltativa, non vanno scritte nel codice.
Esempi graduati:
int x; riserva una cella per un intero, valore indeterminato
int y = 3 * 2; riserva la cella e ci scrive subito 6 (inizializzazione)
char alt = '2'; una cella per un carattere, che contiene il carattere 2
int z = y + 1; l'espressione può usare variabili già dichiarate: z vale 7
Valore iniziale. int x; crea una variabile intera senza darle un valore. Finché non le assegni qualcosa il suo valore è indeterminato, e leggerlo è comportamento indefinito: in pratica di solito trovi quello che era rimasto in memoria, ma lo standard non garantisce niente, nemmeno un numero “casuale” ma stabile. Questo vale per le variabili locali, dichiarate dentro main o dentro un blocco. Le variabili globali, dichiarate fuori da ogni funzione, partono invece da 0.
#include <stdio.h>
int g;
int main(void)
{
int y = 3 * 2;
printf("g = %d, y = %d\n", g, y);
return 0;
}
Stampa g = 0, y = 6 (verificato): g è globale e parte da 0, y è inizializzata.
Controesempi (verificati, il primo compila con un warning, il secondo non compila):
int x;
printf("%d\n", x); warning: 'x' is used uninitialized
in una prova ha stampato 32767
totale = 5; error: 'totale' undeclared (first use in this function)
Il primo è un errore semantico: compila, gira, stampa un numero che non vuol dire niente. Il secondo è un errore che il compilatore vede: usi un nome che non hai mai dichiarato.
1.12Assegnazione
L’espressione a destra può contenere (slide 51-52):
- un valore costante:
10,3.14,'2'(un carattere fra apici singoli); - un identificatore di variabile:
altezza; - una combinazione di espressioni con operatori (
+,-,*,/,%) e parentesi.
Esecuzione (slide 56). Due passi, sempre in quest’ordine:
- si valuta l’espressione a destra di =, ottenendo un r-value;
- si memorizza quel risultato nella cella (l-value) indicata a sinistra.
x = x + 1; con x che vale 6
passo 1: x + 1 -> leggo x (r-value 6), sommo 1 -> 7
passo 2: x = -> scrivo 7 nella cella di x (l-value)
Proprio perché la destra si valuta prima, x = x + 1 ha senso: quando si scrive, il vecchio valore è già stato letto.
Esempi graduati sulla stessa variabile:
#include <stdio.h>
int main(void)
{
int x = 6;
x = x + 1;
printf("%d\n", x);
x = x * 2;
printf("%d\n", x);
x = 3 * x - x;
printf("%d\n", x);
return 0;
}
| istruzione | destra valutata con il vecchio x | x dopo |
|---|---|---|
int x = 6; | 6 | |
x = x + 1; | 7 | |
x = x * 2; | 14 | |
x = 3 * x - x; | 28 |
Output (verificato): 7, 14, 28, uno per riga. Nell’ultima riga le due x a destra valgono entrambe 14: l’assegnazione non avviene a metà del calcolo.
L’assegnazione copia. altezza = lunghezza; copia il valore di lunghezza nella cella di altezza. Le due variabili restano due celle separate: se dopo cambi lunghezza, altezza non se ne accorge.
#include <stdio.h>
int main(void)
{
int lunghezza = 10;
int altezza;
altezza = lunghezza;
lunghezza = 20;
printf("lunghezza = %d, altezza = %d\n", lunghezza, altezza);
return 0;
}
Stampa lunghezza = 20, altezza = 10 (verificato). Non è un’equazione che resta vera per sempre: è una fotografia del valore nel momento in cui si esegue.
Lo stesso fatto spiega perché per scambiare due variabili serve una terza cella. a = b; b = a; non scambia: la prima istruzione sovrascrive a, e la seconda copia in b il valore che a ha adesso, cioè quello di b. Con a = 3 e b = 4 si ottiene 4 4. Con una variabile di appoggio c si salva prima il vecchio a:
Carattere e numero. '2' è il carattere 2, non il numero 2: in ASCII vale 50. Con char alt = '2';, printf("%c %d\n", alt, alt); stampa 2 50 (verificato): lo stesso contenuto, letto come carattere con %c e come numero con %d.
Sintassi generale (slide 53-54 e slide 64). La forma “variabile = valore”, che la slide 54 attribuisce a ChatGPT, non copre tutti i casi. La sintassi vera dell’operatore di assegnazione semplice è:
exp1 = exp2
exp1deve essere un’espressione dotata di l-value: deve indicare una cella.x = 5va bene,5 = xex + 1 = 5no, perché5ex + 1sono solo valori, non posti. gcc:lvalue required as left operand of assignment(verificato su entrambi).exp1edexp2devono avere tipi compatibili.- L’assegnazione è essa stessa un’espressione, e il suo valore è quello di
exp2. Quindi si può usare dentro un’altra espressione. - L’operatore = associa a destra.
Perché “espressione dotata di l-value” e non “variabile”? Perché a sinistra possono stare cose che non sono un nome semplice ma indicano comunque una cella: l’elemento di un array v[3], il campo di una struct, la cella puntata da un puntatore *p. Arriveranno con Array e Puntatori.
L’assegnazione come espressione, in due esempi:
#include <stdio.h>
int main(void)
{
int x;
int y;
printf("%d\n", x = 4);
y = (x = 3) + 1;
printf("x = %d, y = %d\n", x, y);
return 0;
}
Output (verificato): 4, poi x = 3, y = 4. In printf("%d\n", x = 4) l’assegnazione scrive 4 in x e vale 4, ed è quel 4 che si stampa. In y = (x = 3) + 1 prima si esegue x = 3, che vale 3, poi si somma 1 e si scrive 4 in y.
Assegnazione a catena. Perché = associa a destra, una catena si legge raggruppando da destra:
a = b = c = d = 5;
equivale a
a = (b = (c = (d = 5)));
Si parte da destra: d = 5 scrive 5 in d e vale 5, quel 5 viene assegnato a c, e così via fino ad a. Controesempio: se = associasse a sinistra, ((a = b) = c) non avrebbe senso, perché a = b è un valore e non una cella. La catena funziona solo grazie all’associatività a destra.
2Metodo
Riconoscere un errore.
- Il compilatore si ferma con
error? Allora è sintassi o un nome non dichiarato:;mancante, parentesi non chiusa, identificatore non valido, keyword usata come nome, maiuscola sbagliata (Printf), l-value mancante a sinistra di =. - Compila (magari con
warning) ma il risultato è sbagliato o il programma si blocca? Allora è semantica: variabile non inizializzata,&dimenticata inscanf, divisione per zero, formula sbagliata.
Dire se un identificatore è valido. Controlla nell’ordine: il primo carattere è una lettera o _? Gli altri sono tutti lettere, cifre o _ (niente spazi, -, accenti, .)? È diverso da tutte le 32 keyword (attenzione a int, char, double, sizeof, return)? Se tutte e tre le risposte sono sì, è valido. Le maiuscole contano: Int e INT sono validi.
Leggere un’assegnazione.
- Guarda a sinistra di =: deve essere una cosa con una cella (l-value). Se è un numero o un’operazione, è un errore.
- Calcola il valore dell’espressione a destra usando i valori attuali delle variabili.
- Scrivi il risultato nella cella a sinistra. Solo adesso la variabile cambia.
- Con più = in fila, parti da quello più a destra.
- Se c’è un’assegnazione fra parentesi dentro un’espressione, eseguila (cambia la variabile) e usa il valore assegnato come suo valore.
Tracciare un programma a mano. Fai una tabella con una colonna per variabile e una riga per istruzione, e aggiorna solo la colonna della variabile a sinistra di =. Le variabili dichiarate e non ancora assegnate valgono ”?”. Quando incontri una printf, scrivi l’output usando la riga corrente della tabella, carattere per carattere (spazi e \n compresi).
| istruzione | lunghezza | altezza | peso |
|---|---|---|---|
lunghezza = 10; | 10 | ? | ? |
altezza = lunghezza; | 10 | 10 | ? |
peso = 10 * altezza * (lunghezza + 1); | 10 | 10 | 1100 |
Controllo finale: rileggi solo le printf e verifica che ogni %d corrisponda alla colonna giusta, nell’ordine degli argomenti.
Scrivere un programma che legge e stampa.
#include <stdio.h>,int main(void), le graffe.- Dichiara una variabile per ogni dato da leggere e per ogni risultato intermedio, una per riga.
- Un messaggio con
printfche dice cosa inserire. scanfcon un%dper dato e una&per variabile; controlla che restituisca il numero di dati attesi, altrimenti messaggio ereturn 1;.- Calcola con assegnazioni, stampa con
printf, chiudi conreturn 0;.
3Esempi svolti a lezione
3.1Hello World
(slide 10) Le slide propongono di copiarlo su onlinegdb.com scegliendo il C:
#include <stdio.h>
int main(int argc, char *argv[])
{
printf("Hello World!\n");
}
Stampa Hello World! e va a capo (verificato). Con -Wextra gcc dà due warning, unused parameter 'argc' e unused parameter 'argv', ma compila. La slide 11 mostra lo stesso programma in Java, Fortran e PHP.
3.2Togliere pezzi a Hello World
(slide 28) L’esercizio: togli pezzi al programma, per esempio il ; o il \n nella riga di printf, e leggi i messaggi di errore o il cambiamento nell’output. Fatto con gcc 16 (verificato):
| Cosa togli | Cosa succede | Tipo |
|---|---|---|
il ; dopo printf(...) | error: expected ';' before 'return' (con la versione con return 0;): gcc si accorge che manca quando trova la parola dopo | sintassi, niente eseguibile |
il \n | compila, stampa Hello World! senza andare a capo: il prompt del terminale finisce attaccato sulla stessa riga | nessun errore, cambia l’output |
#include <stdio.h> | error: implicit declaration of function 'printf' | il compilatore non conosce printf |
una " | errore missing terminating " character | sintassi |
Il messaggio sul ; mancante cita il simbolo successivo (return), che può stare sulla riga dopo: quando l’errore sembra su una riga giusta, guarda la fine di quella prima.
3.3Istruzioni di I/O
(slide 41) L’esempio delle slide è scanf(&x); e printf((a-z)/10);, nella forma semplificata. Scritto in C vero, leggendo a e z:
#include <stdio.h>
int main(void)
{
int a;
int z;
if (scanf("%d", &a) != 1 || scanf("%d", &z) != 1) {
printf("servono due numeri interi\n");
return 1;
}
printf("%d\n", (a - z) / 10);
return 0;
}
Con input 57 e 7 (sulla stessa riga o su due righe, scanf salta gli spazi e gli a capo) stampa 5: . Con ciao o con 5 x stampa servono due numeri interi (verificato). Il || valuta la seconda scanf solo se la prima è andata bene (Espressioni, operatori e costanti, lazy evaluation).
3.4Le assegnazioni della slide 52
(slide 51-52) Le slide scrivono Lunghezza = 10; con la maiuscola e poi lunghezza + 1 con la minuscola, e lo stesso per Altezza e altezza: per il C sarebbero due variabili diverse. Qui tutto minuscolo. La dichiarazione int x = 3 * 2; è quella della slide 50.
#include <stdio.h>
int main(void)
{
int lunghezza;
int altezza;
int peso;
int x = 3 * 2;
char alt;
int a;
int b;
int c;
int d;
lunghezza = 10;
alt = '2';
altezza = lunghezza;
peso = 10 * altezza * (lunghezza + 1);
x = x + 1;
a = b = c = d = 5;
printf("peso = %d, x = %d, alt = %c\n", peso, x, alt);
printf("a = %d, b = %d, c = %d, d = %d\n", a, b, c, d);
return 0;
}
Tracing:
| istruzione | lunghezza | altezza | peso | x | alt | a b c d |
|---|---|---|---|---|---|---|
| dichiarazioni | ? | ? | ? | 6 | ? | ? ? ? ? |
lunghezza = 10; | 10 | ? | ? | 6 | ? | ? ? ? ? |
alt = '2'; | 10 | ? | ? | 6 | '2' | ? ? ? ? |
altezza = lunghezza; | 10 | 10 | ? | 6 | '2' | ? ? ? ? |
peso = 10 * altezza * (lunghezza + 1); | 10 | 10 | 6 | '2' | ? ? ? ? | |
x = x + 1; | 10 | 10 | 1100 | 7 | '2' | ? ? ? ? |
a = b = c = d = 5; | 10 | 10 | 1100 | 7 | '2' | 5 5 5 5 |
Output (verificato):
peso = 1100, x = 7, alt = 2
a = 5, b = 5, c = 5, d = 5
La slide 64 dichiara int a, b, c, d, e; in una riga sola: è C valido, ma qui si tiene una dichiarazione per riga, che si legge meglio e non inganna con i puntatori (int* p, q; dichiara un puntatore e un intero).
3.5L’esecuzione di x = x + 1
(slide 56) È la figura in Assegnazione: valutazione della destra con il vecchio valore, poi scrittura nella cella. La slide aggiunge che “a sinistra dell’operatore = può in generale esserci un’espressione che deve essere valutata e deve avere un l-value”: è la sintassi exp1 = exp2.
3.6La catena della slide 65
(slide 64-65, aggiunte nella versione del deck di fine settembre). La slide 64 riprende la catena con cinque variabili, e = d = c = b = a = 1;, che equivale a (e = (d = (c = (b = (a = 1)))));. La 65 la fa provare su onlinegdb: stampa le variabili prima (BEFORE) e dopo (AFTER) la catena. Il programma della slide:
#include <stdio.h>
/* Assegnamenti di variabili */
int main(int argc, char *argv[])
{
int a;
int b=2;
int c=3 * 2;
int d,e;
printf("BEFORE\n");
printf("a = %d \n",a);
printf("b = %d \n",b);
printf("c = %d \n",c);
printf("d = %d \n",d);
printf("e = %d \n",e);
e=d=c=b=a=1; //Catena di Assegnamenti
printf("AFTER\n");
printf("a = %d \n",a);
printf("b = %d \n",b);
printf("c = %d \n",c);
printf("d = %d \n",d);
printf("e = %d \n",e);
}
a, d ed e sono dichiarate senza valore e stampate nel BEFORE: è proprio il caso del valore indeterminato. gcc con -Wall avvisa tre volte ('a' is used uninitialized, lo stesso per d ed e). Compilato ed eseguito qui, il BEFORE ha stampato a = 0, d = -712967384, e = 32767: numeri senza significato, che cambiano da una macchina all’altra. L’AFTER invece è sempre lo stesso.
La versione corretta inizializza tutto a 0:
#include <stdio.h>
int main(void)
{
int a = 0;
int b = 2;
int c = 3 * 2;
int d = 0;
int e = 0;
printf("BEFORE\n");
printf("a = %d \n", a);
printf("b = %d \n", b);
printf("c = %d \n", c);
printf("d = %d \n", d);
printf("e = %d \n", e);
e = d = c = b = a = 1;
printf("AFTER\n");
printf("a = %d \n", a);
printf("b = %d \n", b);
printf("c = %d \n", c);
printf("d = %d \n", d);
printf("e = %d \n", e);
return 0;
}
Tracing della catena, dal = più a destra:
| passo | assegnazione | valore dell’assegnazione | a | b | c | d | e |
|---|---|---|---|---|---|---|---|
| prima | 0 | 2 | 6 | 0 | 0 | ||
| 1 | a = 1 | 1 | 1 | 2 | 6 | 0 | 0 |
| 2 | b = (a = 1) | 1 | 1 | 1 | 6 | 0 | 0 |
| 3 | c = (...) | 1 | 1 | 1 | 1 | 0 | 0 |
| 4 | d = (...) | 1 | 1 | 1 | 1 | 1 | 0 |
| 5 | e = (...) | 1 | 1 | 1 | 1 | 1 | 1 |
Output (verificato; ogni riga finisce con uno spazio prima dell’a capo, come nella printf del prof):
BEFORE
a = 0
b = 2
c = 6
d = 0
e = 0
AFTER
a = 1
b = 1
c = 1
d = 1
e = 1
La catena sovrascrive anche b e c, che avevano già un valore: dopo la riga valgono tutte 1.
4Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Il Linguaggio C (esercizi).
5Errori tipici
- Dimenticare il
;in fondo a un’istruzione: errore di sintassi, che gcc segnala citando il simbolo dopo (expected ';' before 'return'), spesso sulla riga successiva. - Dimenticare la
&inscanf: compila (con un warning) e il programma scrive in una cella sbagliata, di solito finisce inSegmentation fault. - Non controllare il valore di ritorno di
scanf: con input sbagliato si lavora su una variabile senza valore. - Usare una variabile prima di averle dato un valore: per le locali il valore è indeterminato (eseguendo il programma della slide 65 è uscito
d = -712967384, e su un altro computer esce un altro numero). - Leggere
x = x + 1come un’equazione, o aggiornare una variabile a metà del calcolo della destra. - Pensare che
altezza = lunghezza;“colleghi” le due variabili: copia il valore in quel momento, poi sono indipendenti. - Scambiare con
a = b; b = a;: il valore diaè perso, serve una variabile di appoggio. - Scrivere = credendo di confrontare: = assegna, il confronto è == (Istruzioni condizionali).
- Confondere
'2'(carattere, codice 50) con2(numero). - Usare una parola chiave come nome di variabile (
int double;,int int;), o un nome con spazi, trattini o accenti. - Scrivere lo stesso nome con maiuscole diverse (
Lunghezzaelunghezza,Printf): per il C sono nomi diversi. - Scrivere
scanf(&x)eprintf(x)come nelle slide: è la forma semplificata, il C vero vuole la stringa di formato.
6Domande
-
Che differenza c’è fra sintassi e semantica di un linguaggio?
-
Porta un esempio di due istruzioni C sintatticamente diverse con la stessa semantica.
-
Che differenza c’è fra compilazione e interpretazione?
-
Quali sono le fasi dallo scrivere un programma C all’eseguirlo, e cosa fa ciascuna?
-
Cosa fa il linker?
-
Cosa sono standard input e standard output?
-
Quali sono le regole per costruire un identificatore valido in C?
-
Cosa significa che il C è case sensitive?
-
Da quali due parti è composto un programma C?
-
Quali sono le quattro caratteristiche di una variabile?
-
Cosa sono l-value e r-value?
-
In che ordine si esegue un’assegnazione?
-
Perché
a = b = c = 5;è valido e a cosa equivale? -
Perché in
scanf("%d", &x)serve la&davanti ax? -
Che differenza c’è fra un errore e un warning del compilatore? Fai un esempio di errore semantico che gcc segnala solo come warning.
-
Perché
5 = x;ex + 1 = y;non compilano, mentrex = 5;sì? -
Qual è la sintassi generale dell’assegnazione semplice, e quali condizioni deve rispettare?
-
Qual è il valore di un’espressione di assegnazione come
x = 4, e dove si può usare? -
Che valore ha una variabile locale dichiarata senza inizializzazione? E una globale?
-
Cosa restituisce
scanf, e perché va controllato? -
Perché
a = b; b = a;non scambia due variabili, e come si fa? -
Cos’è la macchina astratta di un linguaggio, e qual è il suo componente essenziale?