Sintesi e sfide: primi passi

Riepilogo

Questa lezione chiude la prima unità del corso, dedicata ai primi passi nella programmazione in C++. Ricostruisce la catena di concetti che va dal problema specificato all’errore classificato secondo il suo momento, passando per l’algoritmo, il codice sorgente, la compilazione e il collegamento, l’eseguibile e la comunicazione del programma con l’esterno; separa ciò che di tutto questo vale in qualsiasi linguaggio da ciò che è proprio di C++; raccoglie il comportamento indefinito che l’unità ha mostrato e la regola del corso che ne deriva, compilare sempre con gli avvisi e, durante lo sviluppo, con i sanitizer; ripete nella sua valutazione d’uscita le abilità della valutazione d’ingresso; e termina con sei sfide che combinano l’unità intera: il resto con il minor numero di monete, una tabella allineata senza cicli, un programma con cinque difetti di cinque tipi, un esperimento sul buffer di output, una data con formato fisso e la spiegazione del compilatore a chi conosce solo un linguaggio interpretato.

Obiettivi di apprendimento

Percorrere senza aiuto il cammino dall’enunciato al programma eseguito: specificare, scrivere l’algoritmo, seguirlo a mano, scriverlo in C++, compilarlo con le opzioni del corso, eseguirlo e verificarne il risultato.
Spiegare quale strumento agisce in ciascun passo di quel cammino (editor, preprocessore, compilatore, linker, sanitizer) e che cosa ciascuno riceve e consegna.
Riconoscere il tipo di un errore (di compilazione, di collegamento, di esecuzione o di logica) dalla sua manifestazione, e correggere più errori nell’ordine in cui si rivelano.
Spiegare con un esempio che cos’è il comportamento indefinito e perché il corso compila con avvisi e sanitizer.
Separare, in ciò che si è appreso nell’unità, ciò che vale in qualsiasi linguaggio da ciò che è proprio di C++.

Ciò che l’unità ha ottenuto

L’unità si è proposta di condurre chi non ha mai programmato da un problema enunciato in linguaggio corrente fino a un programma che compila, si esegue, legge dati e scrive risultati, sapendo che cosa ha fatto ogni strumento lungo il cammino. Ci è riuscita appoggiandosi solo su ciò che l’introduzione ha dato per scontato: l’aritmetica scolastica, l’abitudine di seguire istruzioni scritte e l’uso di file e cartelle.

Dal problema all’algoritmo

La lezione Dal problema all’algoritmo ha stabilito che un problema si fissa con la sua specifica, un contratto che promette la postcondizione a ogni input che soddisfa la precondizione e nulla al di fuori di essa. Un algoritmo è una procedura finita, precisa e generale, che si scrive in passi numerati, si segue a mano con una tabella di traccia e si compone di sequenza, decisione e ripetizione; ogni ripetizione si accompagna a una variante, una quantità naturale che decresce a ogni iterazione e garantisce che essa termini.

Programmi, compilatori e C++

La lezione Programmi, compilatori e C++ ha mostrato che il testo di un programma C++ non si esegue così com’è: il preprocessore, il compilatore e il linker lo trasformano in un eseguibile. Ne è derivata la distinzione che attraversa l’unità: ciò che dipende solo dal testo si scopre compilando o collegando, e ciò che dipende dai dati, solo eseguendo. La lezione ha confrontato il modello compilato con quello interpretato e ha giustificato che il corso usi C++23 e lo richieda con -std=c++23.

Installare l’ambiente

La lezione Installare l’ambiente su Windows, macOS e Linux ha installato un compilatore capace di C++23 e Visual Studio Code con la sua estensione per C++. La sua lezione di metodo è che l’editor non compila, ma chiama un compilatore che il terminale deve trovare, e che il testo esatto di un messaggio distingue il malfunzionamento dell’installazione da quello dell’invocazione.

Compilare, eseguire e configurare

La lezione Compilare, eseguire e configurare ha fissato il ciclo di modificare, salvare, compilare, eseguire e leggere, e il comando del corso. Ha distinto l’errore, che impedisce l’eseguibile, dall’avviso, che lo permette ma segnala codice sospetto; ha attivato i sanitizer (quello degli errori di memoria, AddressSanitizer, e quello del comportamento indefinito, UndefinedBehaviorSanitizer), che sorvegliano l’esecuzione, e ne ha mostrato i limiti; e ha spiegato che file, compilatore e console devono concordare su UTF-8.

Anatomia di un programma

La lezione Anatomia di un programma ha sezionato il programma minimo: gli header, che dichiarano ogni dipendenza; main, punto di ingresso il cui valore è il codice di uscita; il namespace std; le istruzioni, i blocchi e i commenti. Ha insegnato a leggere i messaggi a partire dal primo e ha fissato la guida di stile del corso.

Input, output ed errori

La lezione Input, output ed errori ha messo il programma in contatto con l’esterno: std::println scrive esattamente ciò che si chiede, con specifiche di formato, e std::cin legge e si ferma al primo carattere che non serve. Una lettura che inciampa in un carattere che non può formare il numero mette la variabile a zero e lascia lo stream in errore, in silenzio (un numero che non entra nel tipo o un input esaurito lasciano nella variabile un altro valore, e la lezione elenca questi casi); per questo la lettura si verifica. La lezione ha chiuso l’unità classificando gli errori secondo il loro momento: di compilazione, di collegamento, di esecuzione e di logica.