Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
11 set
in corso

Il Linguaggio C

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:

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:

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):

1.3Il linguaggio C

(slide 14-17)

LivelloLinguaggi
altoAda, Pascal, BASIC
medioC, FORTH
bassoassembly

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 LL 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).

CompilazioneInterpretazione
cosa fatraduce tutto il programma in un altro linguaggio (per esempio codice macchina), senza eseguirloesegue direttamente il codice sorgente, un’istruzione alla volta
esecuzioneveloce: la decodifica è già stata fattapiù lenta: ogni istruzione va decodificata mentre gira
costola traduzione può richiedere molto temponessuna traduzione a parte
proefficienza, ottimizzazioniflessibilità, portabilità, interattività (debug a run-time)
contropoca flessibilità, si perde informazione sulla struttura del sorgentescarsa efficienza

Le righe “pro” e “contro” sono della slide 25. Lì la compilazione pura è detta anche “difficile, data la lontananza fra LL e LoL_o”, 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:

Macchina astratta (slide 21-23). Dato un linguaggio LL, la macchina astratta MLM_L è un qualsiasi insieme di strutture dati e algoritmi capace di memorizzare ed eseguire programmi scritti in LL. È 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 MoM_o, 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)

FaseChiCosa succede
Editeditorscrivi il programma e lo salvi su disco (ciao.c)
Preprocesspreprocessoreelabora le direttive che iniziano con #: per esempio #include <stdio.h> viene sostituito dal contenuto del file. Il risultato è un sorgente “espanso”
Compilecompilatoretraduce il sorgente in codice oggetto (ciao.o) e lo salva su disco. Qui escono gli errori di sintassi e i nomi non dichiarati
Linklinkercollega il tuo codice oggetto con altro codice già disponibile, le librerie (per esempio quella che contiene il codice di printf), e produce l’eseguibile
Loadloadercarica l’eseguibile dal disco nella memoria centrale
ExecuteCPUprende 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:

ProblemaFaseMessaggio di gcc 16
manca #include <stdio.h> e usi printfcompilazioneimplicit declaration of function 'printf' (errore)
manca il ;compilazioneexpected ';' before 'return'
scrivi Printf invece di printfcompilazioneimplicit declaration of function 'Printf'; did you mean 'printf'?
media = somma / 0;nessuna: compila con un warninga 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:

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):

PezzoSignificato
#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.

#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:

  1. composti da lettere, cifre e underscore _;
  2. il primo carattere è una lettera o _, mai una cifra;
  3. diversi da tutte le parole chiave.

Le lettere sono quelle inglesi: niente accenti (velocità non va bene, per questo nelle slide è velocita_massima).

ValidiNon validi
a, x, alfa, pippo, a1, xy231a (inizia con una cifra: il compilatore lo legge come il numero 1 seguito da a)
MyFriend, DopoDomania b (contiene uno spazio: sono due identificatori)
velocita_massima, _velocitaint (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:

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:

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:

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).

IstruzioneDirezioneForma nelle slide
scanflegge dallo standard input e mette il dato in una variabilescanf(<variabile>)
printfscrive sullo standard output il valore di un’espressioneprintf(<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:

SegnapostoTipoEsempio
%dintero (int)printf("%d\n", x);
%ccarattere (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 xx e ottieni 0=10 = 1). 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 xx, aggiungi 1, rimettilo in xx”.

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 xx a destra fornisce il suo valore, la xx 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:

Istruzionex usata comey 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-valuer-value
scanf("%d", &x);l-value (&x è l’indirizzo)
printf("%d", x + y);r-valuer-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):

Esecuzione (slide 56). Due passi, sempre in quest’ordine:

  1. si valuta l’espressione a destra di =, ottenendo un r-value;
  2. 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;
}
istruzionedestra valutata con il vecchio xx dopo
int x = 6;6
x = x + 1;6+1=76 + 1 = 77
x = x * 2;7⋅2=147 \cdot 2 = 1414
x = 3 * x - x;3⋅14−14=42−14=283 \cdot 14 - 14 = 42 - 14 = 2828

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

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.

  1. 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 =.
  2. Compila (magari con warning) ma il risultato è sbagliato o il programma si blocca? Allora è semantica: variabile non inizializzata, & dimenticata in scanf, 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.

  1. Guarda a sinistra di =: deve essere una cosa con una cella (l-value). Se è un numero o un’operazione, è un errore.
  2. Calcola il valore dell’espressione a destra usando i valori attuali delle variabili.
  3. Scrivi il risultato nella cella a sinistra. Solo adesso la variabile cambia.
  4. Con più = in fila, parti da quello più a destra.
  5. 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).

istruzionelunghezzaaltezzapeso
lunghezza = 10;10??
altezza = lunghezza;1010?
peso = 10 * altezza * (lunghezza + 1);10101100

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.

  1. #include <stdio.h>, int main(void), le graffe.
  2. Dichiara una variabile per ogni dato da leggere e per ogni risultato intermedio, una per riga.
  3. Un messaggio con printf che dice cosa inserire.
  4. scanf con un %d per dato e una & per variabile; controlla che restituisca il numero di dati attesi, altrimenti messaggio e return 1;.
  5. Calcola con assegnazioni, stampa con printf, chiudi con return 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 togliCosa succedeTipo
il ; dopo printf(...)error: expected ';' before 'return' (con la versione con return 0;): gcc si accorge che manca quando trova la parola doposintassi, niente eseguibile
il \ncompila, stampa Hello World! senza andare a capo: il prompt del terminale finisce attaccato sulla stessa riganessun errore, cambia l’output
#include <stdio.h>error: implicit declaration of function 'printf'il compilatore non conosce printf
una "errore missing terminating " charactersintassi

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: (57−7)/10=50/10=5(57 - 7) / 10 = 50 / 10 = 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:

istruzionelunghezzaaltezzapesoxalta b c d
dichiarazioni???6?? ? ? ?
lunghezza = 10;10??6?? ? ? ?
alt = '2';10??6'2'? ? ? ?
altezza = lunghezza;1010?6'2'? ? ? ?
peso = 10 * altezza * (lunghezza + 1);101010⋅10⋅11=110010 \cdot 10 \cdot 11 = 11006'2'? ? ? ?
x = x + 1;101011007'2'? ? ? ?
a = b = c = d = 5;101011007'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:

passoassegnazionevalore dell’assegnazioneabcde
prima02600
1a = 1112600
2b = (a = 1)111600
3c = (...)111100
4d = (...)111110
5e = (...)111111

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

6Domande