Laboratorio 01: la riga di comando, il compilatore gcc e i primi programmi

Il corso di Programmazione I ha due parti. La teoria è in aula, con Elvio Amparore. Il laboratorio è al laboratorio Turing, davanti a un PC: si scrivono programmi e si provano. Il laboratorio vale 30 ore, cioè 10 lezioni da 3 ore.

Le cose pratiche, dalla slide 3:

• i docenti di laboratorio del canale B sono Valerio Basile e Elisa Marengo;
• orari e avvisi sono sulla pagina Moodle del corso;
• per parlare con un docente scrivi un'email o usa il forum di Moodle. Scrivi solo dall'indirizzo di ateneo, quello che finisce con @edu.unito.it;
• durante il laboratorio ci sono anche due assistenti, studenti del secondo o del terzo anno: chiedi a loro quando ti blocchi.

Entrare in un PC del laboratorio Turing (slide 4–5)

Ti siedi, accendi lo schermo con il tasto in basso a destra ed entri con il login di ateneo. È lo stesso nome utente e la stessa password che usi per il sito di UniTo e per la posta: il nome utente ha la forma nome.cognome.

Puoi scegliere tra Windows e Linux. In tutti e due trovi già il compilatore C e un editor di testo. Puoi anche portare il tuo portatile, ma allora devi installare tu il compilatore (sezione «Il compilatore C sul tuo computer», più avanti).

Ogni volta che entri, il PC riparte da zero: niente modifiche, niente file. E quando esci, tutti i file che hai scritto vengono cancellati.

Le regole del laboratorio (slide 6)

In laboratorio è vietato fare foto, video o registrazioni. Il materiale del corso è protetto dal diritto d'autore: puoi usarlo per studiare, ma non condividerlo sui social o su siti che guadagnano con la pubblicità. Puoi condividere solo il materiale con licenza Creative Commons.

Perché conviene venire ogni settimana (slide 7)

Il corso parte dalle basi: non serve aver già programmato. Le prime settimane possono sembrarti facili se hai fatto un istituto tecnico. Poi però gli argomenti si sommano uno sull'altro. La slide 7 ha due grafici. Chi segue il laboratorio e fa gli esercizi sale piano piano, sempre alla stessa pendenza. Chi salta le lezioni trova prima una parte piatta, «già visto», poi una salita ripida e arriva all'esame con una preparazione incompleta.

Che cosa c'entra il laboratorio con l'esame

L'esame di Programmazione I si fa al PC, nei laboratori, ed è uguale per i tre canali. Scrivi programmi in C in una pagina web con un editor semplice: niente completamento automatico. Un sistema di test automatici, CodeRunner, compila il tuo programma, lo esegue con vari dati e confronta quello che stampa con quello che deve stampare. Compilare vuol dire tradurre il testo in C in un programma che il computer sa eseguire (lezione 02A). CodeRunner lo fa con le opzioni -Wall -Werror, che fermano la traduzione anche per un piccolo avviso: le vedi più avanti in questa lezione.

In laboratorio vedrai lo stesso sistema. Nel 2025/26 le slide del Lab03 («Condizioni booleane») lo presentavano con un esercizio su Moodle che non valeva voto, solo per allenarsi. Le stesse slide dicono tre esiti possibili:

1. errore di compilazione: il programma non compila con -Wall -Werror;
2. il programma compila e gira, ma non passa tutti i test: stampa qualcosa di diverso da quello atteso;
3. il programma compila, gira e passa tutti i test.

Per questo conviene allenarsi da subito come all'esame: editor semplice, compilazione con -Wall -Werror, e stampe scritte esattamente come richiesto.

Di solito usi il computer con il mouse: apri una cartella con un doppio clic, trascini un file nel cestino. C'è un altro modo, più vecchio e più preciso: scrivere che cosa vuoi. Per esempio, invece di aprire la cartella Documenti con un doppio clic, scrivi cd Documenti e premi Invio.

È come una chat con il computer. Tu scrivi un ordine su una riga, premi Invio. Il computer lo esegue e risponde con qualche riga di testo, oppure con un messaggio d'errore se non ha capito. Poi aspetta l'ordine dopo.

Questa finestra si chiama riga di comando, in inglese command line interface, abbreviato CLI. Ha molti altri nomi, e li sentirai tutti: terminale, console, shell (su Linux e macOS), prompt dei comandi (su Windows).

In laboratorio la useremo per fare a mano tutti i passi che trasformano un file di testo scritto in C in un programma che gira. Gli ambienti di sviluppo li fanno con un clic, ma nascondono che cosa succede.

Il prompt

Quando apri il terminale vedi una riga che finisce con un simbolo e un cursore che lampeggia. Quella riga si chiama prompt: è il computer che dice «sono pronto, scrivi».

C:\Users\jon_snow>

È il prompt di Windows. Prima del segno > c'è la cartella in cui ti trovi.

jon_snow@linux:~$

È il prompt di Linux. Prima del segno $ ci sono il nome dell'utente, il nome del computer e la cartella in cui ti trovi. Il segno ~ (si legge «tilde») vuol dire «la tua cartella personale». Su macOS il prompt è simile e finisce con %.

Negli appunti, quando c'è un comando da scrivere, il prompt è già scritto davanti. Tu scrivi solo quello che viene dopo il > o il $.

Come è fatto un comando (slide 11)

Ogni comando ha la stessa forma:

nome_comando  opzioni  argomenti

• il nome dice che cosa fare;
• le opzioni cambiano il modo in cui il comando lavora. Su Linux e macOS cominciano con il trattino -, su Windows con la barra /;
• gli argomenti sono le cose su cui il comando lavora: di solito nomi di file o di cartelle.

Le parti si separano con uno spazio. Ecco gli esempi della slide 11, con le risposte vere del computer.

Su Linux:

$ date
Mon Oct  5 17:53:02 CEST 2026

$ uname
Linux

$ echo "ciao, come stai"
ciao, come stai

• date non ha né opzioni né argomenti: stampa data e ora.
• uname stampa il nome del sistema. Con l'opzione -a (all, tutto) stampa anche il nome del computer, la versione e il tipo di processore, su una riga lunga.
• echo ripete i suoi argomenti. Serve per stampare un messaggio o il valore di qualcosa.

Su Windows:

C:\Users\jon_snow>date /t
Mon 10/05/2026

C:\Users\jon_snow>echo ciao, come stai
ciao, come stai

• date /t stampa la data. Senza l'opzione /t, Windows ti chiederebbe anche di scrivere una data nuova.
• systeminfo, l'altro esempio della slide, stampa molte righe di informazioni sul computer.

I messaggi del mio PC sono in inglese. Su un sistema in italiano date e messaggi d'errore escono in italiano, ma il senso è lo stesso.

Comandi della shell e programmi esterni (slide 12–13)

Alcuni comandi li conosce direttamente la shell: si chiamano comandi integrati (built-in). Esempio: cd, che cambia cartella.

Tutti gli altri sono programmi esterni: file che stanno da qualche parte sul disco. Quando scrivi il loro nome, la shell cerca il file, lo carica in memoria e lo esegue con le opzioni e gli argomenti che hai scritto. Esempio: ls su Linux è il file /usr/bin/ls, cioè il file ls nella cartella bin dentro la cartella usr (come si leggono questi indirizzi lo vedi nella sezione dopo).

Ma dove cerca? Non in tutto il disco: sarebbe troppo lento. Cerca in un elenco di cartelle che si chiama PATH (percorso dei comandi). Il PATH è una variabile d'ambiente: un'informazione con un nome, che il sistema tiene in memoria e che tutti i programmi possono leggere.

Per vedere il PATH (slide 13) si usa echo. Su Linux e macOS il valore di una variabile si chiede con il segno del dollaro davanti al nome:

$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin

È il PATH di partenza di Ubuntu. Le cartelle sono separate dai due punti. Su Windows il nome della variabile va tra due segni di percentuale:

C:\Users\jon_snow>echo %PATH%

Esce una riga molto lunga, diversa da computer a computer. Contiene di sicuro le cartelle di Windows, come C:\Windows\system32 e C:\Windows, separate dal punto e virgola.

Per mandare una lettera serve l'indirizzo completo: paese, città, via, numero. Per dire a un comando su quale file lavorare serve la stessa cosa: l'indirizzo del file sul disco. Un errore nell'indirizzo, e il comando lavora sul file sbagliato o non lo trova. Con rm importante.txt, che cancella un file, è meglio essere precisi.

Le cartelle sono un albero

Le cartelle stanno una dentro l'altra. In cima c'è la cartella radice: su Linux e macOS si scrive /, su Windows è il disco, per esempio C:\. Dentro la radice ci sono altre cartelle, dentro ognuna altre ancora, e così via. Disegnato, sembra un albero rovesciato.

L'esempio delle slide, su Windows:

C:\
└── Users\
    ├── jon_snow\
    │   └── Documenti\
    │       └── cosedafare.txt
    └── topolino\
        └── shared\
            └── foto\
                └── pippo.jpg

Il percorso assoluto (slide 15)

Il percorso assoluto di un file è il suo indirizzo completo: tutte le cartelle da attraversare, dalla radice fino al file, nell'ordine. Tra un nome e l'altro c'è un separatore: la barra / su Linux e macOS, la barra rovesciata \ su Windows.

Il file cosedafare.txt dell'albero qui sopra ha questi percorsi assoluti:

Su Linux le cartelle personali stanno in /home, non in Users. Su macOS stanno in /Users.

Un percorso assoluto funziona sempre, da qualunque cartella tu dia il comando. Il difetto: è lungo da scrivere.

La cartella di lavoro e il percorso relativo (slide 16–17)

Il terminale è sempre «dentro» una cartella: si chiama cartella di lavoro (working directory). È quella scritta nel prompt, prima del > o del $. Per cambiarla si usa cd, da change directory:

C:\Users\jon_snow>cd Documenti

C:\Users\jon_snow\Documenti>

Il prompt è cambiato: ora sei in Documenti.

Un percorso relativo è un indirizzo che parte dalla cartella di lavoro invece che dalla radice. È come dire a un amico che è già in via Pessinetto: «al numero 12», invece di ripetergli paese e città.

Se la cartella di lavoro è C:\Users\jon_snow, questi due comandi cancellano lo stesso file (slide 17):

C:\Users\jon_snow>del Documenti\cosedafare.txt
C:\Users\jon_snow>del C:\Users\jon_snow\Documenti\cosedafare.txt

Come capire se un percorso è assoluto o relativo? Guarda come comincia. Se comincia dalla radice (/ su Linux, C:\ su Windows) è assoluto. Altrimenti è relativo, e il computer gli mette davanti la cartella di lavoro.

I due percorsi speciali: punto e due punti (slide 21–22)

Ogni cartella contiene due nomi speciali:

• . (un punto) è la cartella stessa, cioè la cartella di lavoro;
• .. (due punti) è la cartella che la contiene, quella un gradino più su nell'albero.

Se la cartella di lavoro è Documenti, questi due comandi fanno la stessa cosa (slide 21):

C:\Users\jon_snow\Documenti>del .\verbale.txt
C:\Users\jon_snow\Documenti>del verbale.txt

Il .. serve per risalire. L'esempio della slide 22: sei in C:\Users\jon_snow\Documenti e vuoi copiare qui il file pippo.jpg, che sta nella cartella shared\foto dell'utente topolino. Contiamo i passi nell'albero:

1. da Documenti, .. porta a jon_snow;
2. da jon_snow, un altro .. porta a Users;
3. da Users si scende in topolino, poi in shared, poi in foto;
4. lì c'è pippo.jpg.

Il comando è:

C:\Users\jon_snow\Documenti>copy ..\..\topolino\shared\foto\pippo.jpg .
        1 file(s) copied.

Il . finale è la destinazione: «copialo qui». Su Linux lo stesso comando si scrive con cp e le barre dritte: cp ../../topolino/shared/foto/pippo.jpg ..

I dischi di Windows (slide 18)

Su Windows ogni disco ha una lettera seguita dai due punti. C: è il disco con il sistema e i programmi, come il compilatore e l'editor. D: e le altre lettere sono altri dischi, chiavette o cartelle di rete. Al laboratorio Turing c'è solo C:.

Per passare a un altro disco si scrive la sua lettera, per esempio D:, e si preme Invio. Per andare nella tua cartella Documenti in laboratorio:

cd C:\Users\nome_utente\Documents

Al posto di nome_utente metti il tuo nome utente. Nota che qui la cartella si chiama Documents: è il nome vero che Windows usa su disco, anche quando in Esplora file vedi «Documenti».

Con una decina di comandi fai tutto quello che faresti con il mouse in una cartella: guardare, entrare, creare, copiare, spostare, cancellare. Le slide 19 e 20 li elencano per Windows e per Linux. Qui li vedi in azione, con le risposte vere del computer.

Le sessioni Linux vengono da Ubuntu, quelle Windows dal Prompt dei comandi. Ho usato una cartella di prova con l'albero della sezione precedente e un utente di nome jon_snow, come nelle slide. Nei prompt di Linux scrivo solo $ per abbreviare.

Dove sono? Che cosa c'è qui?

pwd (Linux e macOS, print working directory) stampa la cartella di lavoro. Su Windows lo stesso fa cd scritto da solo.

$ pwd
/home/jon_snow

C:\Users\jon_snow>cd
C:\Users\jon_snow

ls (Linux e macOS, list) elenca i file e le cartelle della cartella di lavoro. Con un argomento elenca un'altra cartella. Su Windows si usa dir.

$ ls
Documenti
$ ls Documenti
cosedafare.txt  verbale.txt

C:\Users\jon_snow>dir Documenti
 Directory of C:\Users\jon_snow\Documenti

10/05/2026  05:52 PM    <DIR>          .
10/05/2026  05:52 PM    <DIR>          ..
10/05/2026  05:52 PM                30 cosedafare.txt
10/05/2026  05:52 PM                 9 verbale.txt
               2 File(s)             39 bytes
               2 Dir(s)  442,681,495,552 bytes free

dir stampa anche data, ora e grandezza in byte. Le cartelle hanno la scritta <DIR>; ci sono anche . e ... Sopra l'elenco dir stampa due righe sul disco (nome e numero di serie), che qui ho tolto. Con l'opzione /b stampa solo i nomi.

Muoversi: cd

cd cartella entra in una cartella. cd .. sale di un gradino. Funziona allo stesso modo su Linux, macOS e Windows, con le barre giuste.

$ cd Documenti
$ pwd
/home/jon_snow/Documenti
$ cd ..
$ pwd
/home/jon_snow

cd non stampa niente quando va tutto bene: cambia solo il prompt. Su Linux cd da solo, o cd ~, riporta nella cartella personale. cd / porta alla radice.

Errore tipico: una cartella che non c'è, o scritta male.

$ cd Cartellachenonce
bash: cd: Cartellachenonce: No such file or directory

C:\Users\jon_snow\Documenti>cd Cartellachenonce
The system cannot find the path specified.

Creare: mkdir, touch, copy NUL

mkdir nome (make directory) crea una cartella vuota. Si scrive così su tutti e tre i sistemi.

touch nome (Linux e macOS) crea un file vuoto. Su Windows lo stesso si fa con copy NUL nome: copia «il niente» in un file nuovo. NUL è un file speciale di Windows, sempre vuoto.

$ mkdir PROVA
$ cd PROVA
$ touch importante.txt
$ ls
importante.txt

C:\Users\jon_snow\Documenti\PROVA>copy NUL importante.txt
        1 file(s) copied.

Errore tipico: la cartella esiste già.

$ mkdir PROVA
mkdir: cannot create directory ‘PROVA’: File exists

C:\Users\jon_snow\Documenti>mkdir PROVA
A subdirectory or file PROVA already exists.

Copiare: cp e copy

cp origine destinazione (Linux e macOS) copia un file. Su Windows si scrive copy origine destinazione. L'originale resta dov'è.

$ cp rilevante.txt copia.txt
$ ls
copia.txt  rilevante.txt

Origine e destinazione possono essere percorsi relativi, come qui, o assoluti:

$ cp /home/jon_snow/Documenti/PROVA/rilevante.txt /home/jon_snow/Documenti/PROVA/copia2.txt

Se la destinazione è una cartella, la copia prende lo stesso nome dell'originale: è il caso di copy … . della slide 22.

Errore tipico: il file da copiare non c'è, o il nome è sbagliato.

$ cp nonce.txt b.txt
cp: cannot stat 'nonce.txt': No such file or directory

C:\Users\jon_snow\Documenti>copy nonce.txt b.txt
The system cannot find the file specified.

Rinominare e spostare: mv, ren, move

Su Linux e macOS un solo comando fa due lavori: mv (move).

• mv importante.txt rilevante.txt cambia il nome del file;
• mv PROVA/rilevante.txt . sposta il file nella cartella di lavoro.

In fondo è la stessa cosa: cambi l'indirizzo del file. Su Windows ci sono due comandi: ren (rename) per cambiare nome, move per spostare.

$ mv importante.txt rilevante.txt
$ ls
rilevante.txt

C:\Users\jon_snow\Documenti\PROVA>ren importante.txt rilevante.txt

C:\Users\jon_snow\Documenti>move PROVA\rilevante.txt .
        1 file(s) moved.

Cancellare: rm, del, rmdir

rm file (Linux e macOS, remove) cancella un file. Su Windows si usa del (delete). Il file non va nel cestino: sparisce subito.

$ rm copia.txt copia2.txt
$ ls
rilevante.txt

rmdir cartella (remove directory) cancella una cartella, ma solo se è vuota. Si scrive così ovunque.

$ rmdir PROVA
rmdir: failed to remove 'PROVA': Directory not empty

C:\Users\jon_snow\Documenti>rmdir PROVA
The directory is not empty.

Prima cancelli i file dentro, poi la cartella. rm da solo non cancella le cartelle:

$ rm PROVA
rm: cannot remove 'PROVA': Is a directory

Leggere un file: cat e type

cat file (Linux e macOS) stampa il contenuto di un file di testo. Su Windows si usa type. Sono comodi per controllare al volo un file corto, per esempio un programma C.

$ cat cosedafare.txt
comprare il pane
studiare C

C:\Users\jon_snow\Documenti>type cosedafare.txt
comprare il pane
studiare C

Errore tipico, il file non c'è:

$ cat nonesiste.txt
cat: nonesiste.txt: No such file or directory

Aprire un file con l'editor

Per scrivere un programma serve un editor di testo. Dalla riga di comando si apre così:

• Windows: start notepad++ rilevante.txt apre il file con Notepad++;
• macOS: open rilevante.txt lo apre con il programma predefinito;
• Linux: xdg-open rilevante.txt fa lo stesso.

La tabella di tutti i comandi

Un programma in C, per il computer, è solo un file di testo. Il processore non lo sa eseguire: capisce soltanto il linguaggio macchina, fatto di numeri. Serve un traduttore, il compilatore. Il viaggio dal testo al linguaggio macchina è spiegato nella lezione 02A; qui vediamo come installarlo e usarlo.

Il C in breve (slide 25–27)

La slide 25 riassume le caratteristiche del C. Il nome si pronuncia «si», all'inglese.

• procedurale e imperativo: scrivi le istruzioni da eseguire e il loro ordine, divise in funzioni;
• strutturato: usa blocchi, cicli e scelte if/else invece dei salti dell'assembly;
• permette la ricorsione: una funzione può chiamare sé stessa (la vedrai verso la fine del corso);
• tipizzato: ogni variabile, cioè ogni casella della memoria con un nome, ha un tipo, per esempio «numero intero». Le variabili le vedi nell'ultima sezione;
• vicino all'hardware: lascia lavorare direttamente sulla memoria.

Quattro di queste caratteristiche sono già nella lezione 02A. Il C è ancora molto usato: nell'indice TIOBE di settembre 2026 è il secondo linguaggio più popolare, dopo Python. Nel sondaggio Stack Overflow 2025 lo usa il 22 % di chi ha risposto (slide 27).

Per cercare come funziona una funzione della libreria, la slide 26 consiglia: cppreference, Wikibooks, Wikipedia e cplusplus.com. Sono in inglese.

Quale compilatore (slide 28)

Di compilatori C ce ne sono molti. Alcuni esistono da decenni e sono tra i programmi più provati al mondo: quasi tutto il software di sistema è scritto in C. Nel corso si usa gcc, ma quello che vedrai vale per quasi tutti i compilatori.

Installarlo (slide 29–33)

Su Linux gcc si installa con il gestore dei pacchetti, il programma che scarica e installa il software. Il comando dipende dalla distribuzione:

sudo apt install build-essential      (Debian, Ubuntu)
sudo dnf install gcc make             (Fedora)

sudo vuol dire «come amministratore»: ti chiede la tua password.

Su macOS si installano gli strumenti da riga di comando di Xcode (Xcode command line tools), dall'App Store o dal sito di Apple. Un modo comodo è scrivere nel terminale xcode-select --install. Su macOS il comando gcc in realtà avvia un altro compilatore, clang, che accetta le stesse opzioni.

Su Windows si usa MinGW-w64, una versione di gcc fatta per Windows. I passi delle slide:

1. scarica l'archivio dalla pagina github.com/niXman/mingw-builds-binaries/releases. La slide 30 dà il link diretto alla versione 15.2.0, un file .7z con nel nome x86_64, win32, seh e msvcrt;
2. l'archivio è un file compresso: estrailo in una cartella tua, per esempio C:\Users\<Nome Utente>\Documents\mingw64. Per aprire i .7z serve un programma come 7-Zip;
3. aggiungi al PATH la cartella bin che sta dentro: C:\Users\<Nome Utente>\Documents\mingw64\bin. È lì che si trova gcc.exe.

Il passo 3, nelle slide 31–33:

1. apri le Impostazioni di sistema;
2. vai su Sistema → Impostazioni avanzate di sistema e clicca su Variabili d'ambiente. Si fa prima come nella figura della slide 31: scrivi «variabili» nella ricerca del menu Start e apri la voce per modificare le variabili d'ambiente del tuo account;
3. nella sezione Variabili utente seleziona Path e clicca su Modifica;
4. clicca su Nuovo e scrivi il percorso della cartella bin di MinGW;
5. conferma con OK in tutte le finestre.

Perché proprio il PATH? Per la sezione «La riga di comando»: quando scrivi gcc, il terminale lo cerca solo nelle cartelle del PATH. Se la cartella bin non c'è, ricevi «not recognized as an internal or external command».

Controllare che funzioni (slide 34)

Apri un Prompt dei comandi nuovo e scrivi where gcc. Il comando where cerca un programma nelle cartelle del PATH e stampa dove l'ha trovato. Se va bene, esce il percorso di gcc.exe:

C:\Users\jon_snow>where gcc
C:\MinGW\bin\gcc.exe

Il percorso dipende da dove hai estratto l'archivio. Se va male, esce un messaggio. È questo nella slide, su un Windows in italiano:

C:\Users\jon_snow>where gcc
INFORMAZIONI: Impossibile trovare i file corrispondenti ai criteri di ricerca indicati.

In inglese il messaggio è INFO: Could not find files for the given pattern(s). Allora ricontrolla il passo del PATH.

L'altro controllo è gcc --version, con due trattini attaccati. Stampa la versione. Sul mio PC:

C:\Users\jon_snow>gcc --version
gcc (MinGW-W64 x86_64-ucrt-posix-seh, built by Brecht Sanders, r4) 16.1.0
Copyright (C) 2026 Free Software Foundation, Inc.

La prima riga cambia con la versione installata. Su Linux e macOS il controllo è lo stesso, gcc --version; al posto di where si usa which gcc.

Con che cosa scrivere il codice (slide 35–36)

Il codice si scrive con un editor di testo semplice, ma pensato per programmare: colora le parole, numera le righe, non cambia i caratteri. Il Blocco note di Windows non va bene. Su Windows le slide consigliano Notepad++; altri editor sono gedit, Sublime Text, Atom.

In laboratorio non si usa un ambiente di sviluppo integrato (IDE). Se vuoi usarne uno a casa, spegni gli strumenti che completano il codice da soli, come Copilot: scriverebbero gli esercizi al posto tuo. L'obiettivo è imparare. E all'esame avrai solo un editor semplice in una pagina web.

I file con il codice C hanno l'estensione .c: sono i file sorgente, cioè le unità di compilazione. I file di intestazione hanno l'estensione .h. Dalla lezione 02A conosci già stdio.h.

Il primo programma del laboratorio è quasi lo stesso della lezione 02A: stampa un saluto. Lì trovi la spiegazione riga per riga. Qui lo trasformiamo davvero in un programma.

Scrivere il file (slide 37)

Apri l'editor, scrivi il testo e salvalo con il nome buongiorno.c:

#include <stdio.h>

int main(void) {
    printf("Buongiorno!\n");
    return 0;
}

In breve: #include <stdio.h> porta dentro le dichiarazioni di printf; main è il punto da cui parte il programma; printf stampa il testo tra virgolette, e \n va a capo; return 0; dice al sistema operativo «tutto bene».

I quattro stadi, in breve (slide 38–39)

Per diventare un programma, il file passa da quattro programmi uno dopo l'altro: il preprocessore (cpp), il compilatore (cc), l'assemblatore (as) e il collegatore, in inglese linker (ld). Li trovi spiegati nella lezione 02A. Il comando gcc li chiama tutti al posto tuo.

Nel percorso si incontrano tre tipi di file:

La figura della slide 39 mostra il caso con tanti sorgenti: ogni file .c diventa un file oggetto, poi il linker li unisce tutti in un solo eseguibile.

Compilare in due passi: -c e il collegamento (slide 40–41)

Primo passo: dal sorgente al file oggetto. L'opzione -c dice a gcc «fermati prima del linker». L'opzione -o (output) sceglie il nome del file prodotto.

$ gcc -c buongiorno.c -o buongiorno.o

Su Windows, secondo la slide 40, il file oggetto si chiama buongiorno.obj. Il nome lo scegli tu con -o: gcc di MinGW scrive comunque lo stesso tipo di file.

Secondo passo: dal file oggetto all'eseguibile. È lo stesso comando gcc, senza -c: così gcc chiama il linker.

$ gcc buongiorno.o -o buongiorno

Su Windows: gcc buongiorno.obj -o buongiorno.exe. Con più file oggetto si elencano tutti: gcc oggetto1.o oggetto2.o -o eseguibile.

Tutto in un passo (slide 42)

Con un solo file sorgente si fanno i due passi insieme:

$ gcc buongiorno.c -o buongiorno

Su Windows: gcc buongiorno.c -o buongiorno.exe. È il modo che userai quasi sempre.

Gli avvisi: -Wall -Werror (slide 43–44)

A volte il compilatore trova un pezzo di codice corretto per le regole del C, ma sospetto: per esempio una variabile che non usi mai. Non si ferma, ma stampa un avviso (warning).

• -Wall accende gli avvisi più utili (all warnings);
• -Werror trasforma ogni avviso in errore: con un solo avviso, il programma non viene prodotto.

$ gcc -Wall -Werror buongiorno.c -o buongiorno

Su Windows: gcc -Wall -Werror buongiorno.c -o buongiorno.exe. Se va tutto bene gcc non stampa niente e trovi il file buongiorno (o buongiorno.exe) nella cartella. Il silenzio è una buona notizia.

Ecco che cosa cambia. Questo programma dichiara una variabile b e non la usa mai:

#include <stdio.h>

int main(void) {
    int a = 5;
    int b = 7;
    printf("a vale %d\n", a);
    return 0;
}

Senza opzioni gcc lo compila in silenzio. Con -Wall -Werror si ferma:

err_inutile.c: In function 'main':
err_inutile.c:5:9: error: unused variable 'b' [-Werror=unused-variable]
    5 |     int b = 7;
      |         ^
cc1.exe: all warnings being treated as errors

Si legge così: nel file err_inutile.c, riga 5, colonna 9, la variabile b non è usata. Tra parentesi quadre c'è il nome dell'avviso; -Werror= vuol dire che -Werror l'ha fatto diventare un errore. Per leggere bene questi messaggi guarda anche la lezione 02A.

Eseguire il programma (slide 45)

Il programma è un file nella cartella di lavoro. Per avviarlo si scrive il suo nome. Su Windows basta il nome:

C:\Users\jon_snow>buongiorno
Buongiorno!

Su Linux e macOS serve ./ davanti, cioè «il file che sta qui»:

$ ./buongiorno
Buongiorno!

Perché il ./? Per la sezione «La riga di comando»: un nome senza percorso viene cercato solo nelle cartelle del PATH, e la cartella di lavoro su Linux non c'è. Scrivere ./ dà un percorso relativo, e allora la shell non cerca più.

$ buongiorno
buongiorno: command not found

Guardare il linguaggio macchina: il disassemblatore (slide 46)

Un disassemblatore fa il viaggio al contrario: prende il programma compilato e mostra le sue istruzioni macchina scritte in assembly. Non torna al C: quello è perso.

Sul mio PC objdump -d buongiorno.exe stampa 2808 righe: c'è anche tutto il codice che il linker ha aggiunto per avviare il programma. La funzione main comincia così:

0000000140001760 <main>:
   140001760:	55                   	push   %rbp
   140001761:	48 89 e5             	mov    %rsp,%rbp
   140001764:	48 83 ec 20          	sub    $0x20,%rsp
   140001768:	e8 da 00 00 00       	call   140001847 <__main>
   14000176d:	48 8d 05 dc 38 00 00 	lea    0x38dc(%rip),%rax
   140001774:	48 89 c1             	mov    %rax,%rcx
   140001777:	e8 ec 1a 00 00       	call   140003268 <puts>
   14000177c:	b8 00 00 00 00       	mov    $0x0,%eax

A sinistra l'indirizzo in memoria, poi i byte dell'istruzione in esadecimale, poi l'istruzione in assembly. È il linguaggio macchina della lezione 02A, per un processore vero. Curiosità: gcc ha sostituito printf con puts, una funzione più veloce che stampa una riga e va a capo. Può farlo perché la stringa, cioè il testo tra virgolette, finiva con \n e non aveva niente da riempire.

Finora i programmi parlano soltanto: stampano sempre la stessa frase. Un programma utile deve anche ascoltare. Per esempio: «dimmi un numero e ti scrivo la sua tabellina». Per questo serve leggere dalla tastiera.

Il programma della slide 48

#include <stdio.h>

int main(void) {
    int number;
    printf("Scrivi un numero intero: ");

    // leggi il numero inserito
    scanf("%d", &number);

    // mostra il numero a video
    printf("Hai scritto: %d\n", number);
    return 0;
}

Lo compili, lo avvii e scrivi 7, poi premi Invio. Sul terminale vedi:

$ ./scrivi_intero
Scrivi un numero intero: 7
Hai scritto: 7

Il primo 7 l'hai scritto tu, il secondo lo stampa il programma. Vediamo le righe nuove, una alla volta.

int number; prepara una variabile: una casella della memoria con un nome, qui number, in cui si può mettere un numero. int dice il tipo: un numero intero, senza virgola. Le variabili sono l'argomento della teoria di questa settimana: per ora basta l'idea della casella con un nome.

printf("Scrivi un numero intero: "); stampa la domanda. Nota che non c'è \n: il cursore resta sulla stessa riga, e il numero che scrivi compare subito dopo i due punti.

scanf("%d", &number); aspetta che tu scriva qualcosa e prema Invio. Poi legge un numero intero e lo mette nella casella number. Due pezzi nuovi:

• "%d" dice che cosa leggere: %d vuol dire «un numero intero scritto in base 10» (la d sta per decimale);
• &number dice dove mettere il numero. Il segno & (si legge «e commerciale») davanti al nome vuol dire «l'indirizzo della casella number». Ricordi la memoria della lezione 01B, fatta di celle numerate? scanf ha bisogno del numero della cella, non di quello che c'è dentro.

printf("Hai scritto: %d\n", number); stampa il testo, ma al posto di %d mette il valore di number. Il %d è un segnaposto: un buco nel testo, riempito dal valore scritto dopo la virgola.

Provare senza scrivere a mano: la pipe

Per provare un programma che legge dalla tastiera puoi scrivere il numero a mano ogni volta. Oppure puoi farglielo arrivare da un altro comando, con la barra verticale |, che si chiama pipe (tubo). Il comando a sinistra stampa, e quello che stampa entra nel programma a destra come se l'avessi scritto tu.

$ echo 7 | ./scrivi_intero
Scrivi un numero intero: Hai scritto: 7

echo 7 stampa 7, la pipe lo passa a scrivi_intero, che lo legge con scanf. Questa volta il 7 non si vede dopo la domanda: nessuno l'ha scritto sul terminale. Nel Prompt dei comandi di Windows si scrive echo 7| scrivi_intero, con lo stesso risultato. È più o meno quello che fa CodeRunner all'esame: dà al tuo programma dei dati già pronti e confronta le stampe.

La tabellina: slide 49

#include <stdio.h>
int main(void) {
    int n;
    printf("Scrivi un numero intero: ");
    scanf("%d", &n);

    // stampa i primi 10 multipli di n
    for (int i = 1; i <= 10; ++i) {
        printf("%d * %d = %d \n", n, i, n * i);
    }
    return 0;
}

Le prime righe le conosci: una casella n, la domanda, la lettura. Poi c'è una cosa nuova, for: è un ciclo, cioè un blocco di istruzioni ripetuto più volte. Lo vedrai a teoria tra un paio di settimane; per leggerlo oggi basta questo:

• int i = 1 crea un contatore i che parte da 1;
• i <= 10 è la condizione: si ripete finché i è al massimo 10;
• ++i aumenta i di 1 dopo ogni giro;
• il blocco tra graffe viene eseguito una volta per ogni valore di i: 1, 2, 3, fino a 10.

È la stessa idea del contatore della lezione 01A, con il controllo prima di ogni giro.

Dentro il ciclo, printf ha tre segnaposto e tre valori dopo la virgola, nello stesso ordine: il primo %d diventa n, il secondo i, il terzo n * i, cioè n per i. L'asterisco * in C è il segno della moltiplicazione.

Con 7:

$ echo 7 | ./tabella_moltiplicazioni
Scrivi un numero intero: 7 * 1 = 7 
7 * 2 = 14 
7 * 3 = 21 
7 * 4 = 28 
7 * 5 = 35 
7 * 6 = 42 
7 * 7 = 49 
7 * 8 = 56 
7 * 9 = 63 
7 * 10 = 70 

La prima riga della tabellina sta dopo la domanda perché, con la pipe, il 7 e l'Invio non si vedono. Scrivendo il numero a mano, 7 * 1 = 7 va sulla riga dopo. Nota anche lo spazio prima del \n nella stringa: ogni riga finisce con uno spazio invisibile. A CodeRunner uno spazio in più o in meno basta per non passare un test.

Gli errori tipici con scanf

Dimenticare la &. È l'errore più comune. Senza &, scanf riceve il contenuto della casella invece del suo indirizzo. Con -Wall -Werror gcc 16.1 se ne accorge:

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

Si legge: il %d vuole un int * (l'indirizzo di un intero, il tipo dei puntatori che vedrai a teoria), ma riceve un int. Il secondo errore dice che n viene usata quando dentro non c'è ancora niente. Senza -Wall, lo stesso programma compila in silenzio, e quando lo esegui scanf scrive in un punto a caso della memoria: di solito il programma si blocca. È il motivo migliore per usare sempre -Wall -Werror.

Un %d senza il suo valore. Ogni segnaposto vuole un valore dopo la virgola:

err_formato.c:6:19: error: format '%d' expects a matching 'int' argument [-Werror=format=]
    6 |     printf("%d e %d\n", x);
      |                  ~^

Scrivere lettere invece di un numero. Se al programma arriva ciao, scanf non trova un numero e non scrive niente nella casella. La casella contiene quello che c'era prima in memoria: un numero a caso. Con ciao, a me ha stampato Hai scritto: 32758. Per ora i programmi del corso si provano solo con numeri.

L'esame di Programmazione I si fa al PC, nei laboratori Turing, Dijkstra e Von Neumann, ed è unico per i tre canali. Appelli 2026/27: lunedì 25/01/2027 e giovedì 11/02/2027, alle 9:00. Scrivi codice C in una pagina web con un editor semplice; CodeRunner lo compila con -Wall -Werror, lo esegue con vari dati e confronta le stampe. Secondo il riepilogo d'esame 2025/26 del canale C il codice viene anche letto: passare i test serve, ma non basta.

Che cosa serve di questo laboratorio

1. Compilare con -Wall -Werror e leggere i messaggi di gcc. All'esame un programma che non compila non passa nessun test. Riconosci al volo expected ';', unused variable, undeclared, e gli errori di formato di printf e scanf.
2. Stampe esatte. CodeRunner confronta il testo carattere per carattere: spazi, a capo, maiuscole. Copia il formato delle printf dal testo dell'esercizio.
3. Leggere con scanf, con la &.
4. Scrivere senza aiuti. Niente IDE, niente completamento automatico, niente Copilot: allenati con Notepad++ o un editor simile.
5. Il terminale all'esame quasi non serve, perché CodeRunner compila per te. Serve per tutto il resto del corso: laboratori, esercizi a casa, e i corsi degli anni dopo.

Errori da evitare in laboratorio

• Uscire senza salvare i file: vengono cancellati.
• Salvare buongiorno.c.txt invece di buongiorno.c.
• Compilare senza -Wall -Werror, e scoprire gli errori solo all'esame.
• Dimenticare la & in scanf.
• Avviare il programma su Linux senza ./.
• Mettere spazi nei nomi dei file.

Riga di comando (CLI)

Finestra in cui si danno ordini al computer scrivendoli, uno per riga. Si chiama anche terminale, console, shell o prompt dei comandi.

Shell

Il programma che legge i comandi sulla riga di comando di Linux e macOS, per esempio bash o zsh.

Prompt

La scritta che precede il cursore e dice che il terminale aspetta un comando, come C:\Users\jon_snow>.

Opzione

Parte di un comando che cambia il suo modo di lavorare: -a su Linux, /t su Windows.

Argomento

Il dato su cui lavora un comando, di solito un file o una cartella.

Comando integrato

Comando eseguito dalla shell stessa, senza avviare un programma, come cd.

PATH

Variabile d'ambiente con l'elenco delle cartelle in cui si cercano i programmi.

Variabile d'ambiente

Informazione con un nome che il sistema tiene in memoria per tutti i programmi, come PATH.

Cartella radice

La cartella in cima all'albero: / su Linux e macOS, il disco come C:\ su Windows.

Percorso assoluto

Indirizzo completo di un file, dalla radice: /home/jon_snow/Documenti/cosedafare.txt.

Percorso relativo

Indirizzo che parte dalla cartella di lavoro: Documenti/cosedafare.txt.

Cartella di lavoro

La cartella in cui si trova il terminale; si cambia con cd.

MinGW-w64

Versione di gcc per Windows.

Editor di testo

Programma per scrivere testo semplice, come Notepad++; il codice C si scrive con un editor.

IDE

Ambiente di sviluppo integrato: editor, compilatore e strumenti in un solo programma. Non si usa in laboratorio né all'esame.

File oggetto

File in linguaggio macchina prodotto da gcc -c (.o oppure .obj); non è ancora un programma.

Eseguibile

Il programma finito, che si avvia: senza estensione su Linux e macOS, .exe su Windows.

Avviso (warning)

Messaggio del compilatore su codice corretto ma sospetto; con -Werror diventa errore.

Disassemblatore

Programma che mostra in assembly il linguaggio macchina di un eseguibile, come objdump -d.

scanf

Funzione che legge dati dalla tastiera; con %d legge un intero e lo mette all'indirizzo dato con &.

Segnaposto

Codice come %d dentro la stringa di printf, sostituito dal valore scritto dopo la virgola.

Pipe

La barra verticale tra due comandi: quello che stampa il primo entra nel secondo come se fosse scritto dalla tastiera.

CodeRunner

Il sistema di Moodle che compila il codice con -Wall -Werror, lo esegue con dati di prova e confronta le stampe.

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

• So come si entra in un PC del laboratorio Turing e che i file si perdono all'uscita.
• So riconoscere nome, opzioni e argomenti di un comando.
• So spiegare che cos'è il PATH e che cosa vuol dire «command not found».
• So distinguere percorso assoluto e relativo e usare . e ...
• So usare pwd, ls, cd, mkdir, touch, cp, mv, rm, rmdir e cat su Linux o macOS.
• So usare cd, dir, mkdir, copy NUL, copy, ren, move, del, rmdir e type su Windows.
• So installare gcc sul mio computer e controllarlo con gcc --version.
• So compilare con gcc -Wall -Werror sorgente.c -o eseguibile ed eseguire il programma.
• So separare compilazione (-c) e collegamento, e che cosa mostra objdump -d.
• So leggere un intero con scanf e la & e stamparlo con printf e %d.
• So provare un programma con echo e la pipe.
• So leggere i messaggi di gcc: riga, colonna, descrizione e nome dell'avviso.