Dal flusso sequenziale alle decisioni, if ed else

Pensa a una ricetta. Ci sono passi da fare in fila: «sbatti le uova, aggiungi la farina». Ci sono scelte: «se l'impasto è troppo duro, aggiungi latte». E ci sono ripetizioni: «mescola finché non ci sono più grumi». Con questi tre tipi di passo si scrive qualunque ricetta.

I programmi funzionano allo stesso modo. La programmazione strutturata usa tre strutture di controllo:

Negli anni '60 non era ancora chiaro quali strumenti servissero per descrivere l'ordine delle istruzioni: molti programmi saltavano da un punto all'altro, come la versione V5 della lezione 01A. Nel 1966 Corrado Böhm e Giuseppe Jacopini, due informatici italiani, hanno dimostrato che sequenza, selezione e iterazione bastano per scrivere qualunque algoritmo. È il teorema di Böhm-Jacopini, e da lì vengono i linguaggi di oggi: pochi pezzi semplici, che si mettono uno dentro l'altro per costruire programmi complicati quanto si vuole.

In questa lezione c'è la selezione. L'iterazione arriva con while e for.

L'esempio delle slide: se piove prendo l'ombrello, altrimenti esco senza. Il programma arriva a un bivio, si fa una domanda, e segue una delle due strade. Si chiama controllo di flusso condizionato: il «flusso» è l'ordine in cui le istruzioni vengono eseguite.

La forma più semplice ha una sola strada in più:

if (condizione) {
    // codice eseguito solo se la condizione è vera
}

• Se la condizione è vera (cioè diversa da 0), il programma entra nel blocco tra le graffe.
• Se è falsa (cioè 0), salta il blocco e continua dopo la }.

La condizione è un'espressione booleana della 03C, sempre tra parentesi tonde. L'esempio delle slide:

int voto = 25;
if (voto >= 18) {
    printf("Esame superato!\n");
}

Stampa Esame superato!. Con voto = 15 non stampa niente: il blocco viene saltato.

Con else, «altrimenti», il programma ha due strade, e ne percorre sempre esattamente una:

if (condizione) {
    // blocco A: se la condizione è vera
}
else {
    // blocco B: se la condizione è falsa
}

L'esempio delle slide è la batteria del telefono:

int batteria = 15;

if (batteria < 20) {
    printf("Batteria quasi scarica! Collega il caricatore.\n");
}
else {
    printf("Batteria sufficiente.\n");
}

Con 15 stampa il primo messaggio, con 20 o più il secondo. Non succede mai che stampi tutti e due, e nemmeno che non ne stampi nessuno.

A volte le strade sono più di due. Il semaforo dell'esempio ha tre colori, più il caso di un colore sbagliato. Si mettono le domande in fila, con else if:

char colore = 'G';   // R = Rosso, G = Giallo, V = Verde
if (colore == 'R') {
    printf("Fermati!\n");
}
else if (colore == 'G') {
    printf("Attenzione, rallenta.\n");
}
else if (colore == 'V') {
    printf("Puoi passare.\n");
}
else {
    printf("Colore non valido!\n");
}

Il programma fa le domande dall'alto in basso:

1. il colore è 'R'? No, allora passa alla domanda dopo;
2. il colore è 'G'? Sì: stampa Attenzione, rallenta. e salta tutto il resto, fino alla fine della catena.

Se nessuna condizione è vera, entra nell'else finale, il caso di default. Ho provato tutti i casi: 'R', 'G' e 'V' danno i loro messaggi; 'g' minuscolo dà Colore non valido!, perché 'g' e 'G' sono caratteri diversi, con codici ASCII 103 e 71.

Gli if sono semplici da scrivere e facili da sbagliare. Le slide raccolgono gli errori che si vedono più spesso. Per ognuno ho controllato che cosa fa gcc.

Un uguale solo

if (a = 5) { ... }  // ERRORE: assegnamento

a = 5 non chiede niente: mette 5 in a, e vale 5, cioè vero. Il blocco viene eseguito sempre, qualunque cosa ci fosse in a. gcc con -Wall avvisa: suggest parentheses around assignment used as truth value. Con -Werror non compila, ed è una fortuna.

Le graffe dimenticate

if (x > 0)
    printf("Positivo\n");
    printf("Errore!\n"); // eseguito sempre

Senza graffe, l'if comanda una sola istruzione, la prima. La seconda printf è rientrata come se dipendesse dall'if, ma per il C il rientro non conta niente: viene eseguita sempre. gcc con -Wall avvisa: this 'if' clause does not guard..., e con -Werror non compila. Le slide consigliano di mettere sempre le graffe, anche con una sola istruzione.

L'ordine sbagliato

if (num % 2 == 0) {
    printf("Pari non nullo\n");
}
else if (num == 0) {
    printf("Zero\n");   // Mai raggiunto
}

Lo 0 è pari: con num = 0 la prima condizione è già vera, e il programma stampa Pari non nullo, che è falso. Il blocco Zero non viene mai raggiunto. Si corregge mettendo prima il caso più specifico:

if (num == 0) {
    printf("Zero\n");
}
else if (num % 2 == 0) {
    printf("Pari non nullo\n");
}

Ho provato: con 0 la prima versione stampa Pari non nullo, la seconda Zero. Con 4 tutte e due stampano Pari non nullo.

Condizioni che non diventano mai vere

if (x > 10) {
    ...
}
else if (x > 20) {
    ... // mai eseguito!
}

Ogni numero maggiore di 20 è anche maggiore di 10, quindi entra già nel primo blocco. Il secondo non si raggiunge mai. Qui gcc non avvisa: l'errore è di logica, e lo trovi solo ragionando. Le soglie vanno in ordine dalla più alta alla più bassa (x > 20 prima di x > 10), oppure con intervalli precisi.

L'else mancante

È buona norma gestire tutti i casi, con un else finale anche solo per stampare un errore. Così il programma non arriva mai in una situazione che non hai previsto.

Condizioni troppo lunghe

if (a > 10 && b < 5 || c == 7 && !(d%2)) {
    ...
}

Come nella 03C, una condizione così si spezza in variabili bool con un nome:

bool condA = (a > 10 && b < 5);
bool condB = (c == 7 && d % 2 == 0);

if (condA || condB) { ... }

La prima versione, tra l'altro, con -Wall -Werror non compila: gcc chiede le parentesi intorno agli && dentro l'||.

L'esempio delle slide: leggere due interi x e y e stamparli dal più piccolo al più grande. La prima idea è stampare in due ordini diversi:

#include <stdio.h>

int main(void) {
    int x, y;
    printf("Inserisci x:");
    scanf("%d", &x);
    printf("Inserisci y:");
    scanf("%d", &y);
    if (y < x) {
        printf("%d %d", y, x);
    }
    else { // y >= x
        printf("%d %d", x, y);
    }
}

La seconda idea è più utile: se sono nell'ordine sbagliato, si scambiano. Dopo l'if le variabili sono in ordine, e basta una sola printf. È lo scambio con la variabile d'appoggio della 03A, fatto solo quando serve: uno scambio condizionato.

#include <stdio.h>

int main(void) {
    int x, y;
    printf("Inserisci x:");
    scanf("%d", &x);
    printf("Inserisci y:");
    scanf("%d", &y);
    if (y < x) {
        //scambio condizionato
        int temp = x;
        x = y;
        y = temp;
    }
    printf("%d %d", x, y);
}

Con 10 e 5 stampa 5 10; con 3 e 8 stampa 3 8, senza scambio.

Che cosa succede nella memoria

Le slide 15–20 seguono il programma con l'input 10 e 5, una riga alla volta. Ogni riga della tabella è lo stato della memoria dopo l'istruzione indicata.

La cosa nuova è l'ultima colonna. temp è dichiarata dentro il blocco dell'if: nasce sullo stack quando il programma arriva alla sua dichiarazione, e alla } del blocco viene tolta dallo stack. Dopo l'if non esiste più.

Come si legge. È la regola delle variabili locali della 02B, applicata ai blocchi dell'if. Se dopo l'if scrivi printf("%d", temp);, gcc si ferma: error: 'temp' undeclared. L'ho provato.

Questo è utile: temp serve solo per lo scambio, e dichiararla dentro il blocco evita che qualcuno la usi per sbaglio più avanti.

Un if dentro un else funziona, ma spinge il codice sempre più a destra e si legge male. L'esempio delle slide è il prezzo del biglietto: gratis sotto i 6 anni, ridotto sotto i 18, intero dai 18 in su.

if (eta < 6) {
    printf("Biglietto gratuito\n");
}
else {
    if (eta < 18) {
        printf("Biglietto ridotto\n");
    }
    else {
        printf("Biglietto intero\n");
    }
}

La stessa scelta con else if sta su un solo livello:

if (eta < 6) {
    printf("Biglietto gratuito\n");
}
else if (eta < 18) {
    printf("Biglietto ridotto\n");
}
else {
    printf("Biglietto intero\n");
}

Le due versioni fanno esattamente la stessa cosa. Ho provato i casi limite, quelli sul confine tra due fasce: 5 dà gratuito, 6 ridotto, 17 ridotto, 18 intero.

Nota che la seconda condizione è solo eta < 18, non 6 <= eta && eta < 18: se il programma arriva lì, eta < 6 è già falso, quindi eta è almeno 6. Un else if porta con sé il «no» di tutte le domande prima.

Alcuni if compaiono in quasi tutti i programmi. Vale la pena saperli scrivere senza pensarci.

Il massimo di due numeri

int a, b, max;
scanf("%d%d", &a, &b);
// determina il massimo tra a e b
if (a > b) {
    max = a;
}
else {
    max = b;
}
// in questo punto max contiene il massimo tra a e b

Con 4 e 9, max vale 9. Con due numeri uguali va bene lo stesso: si prende b, che vale quanto a.

Controllare l'input

Prima di usare un valore letto, si controlla che scanf l'abbia letto davvero, come nella 02C:

int valore;
if (scanf("%d", &valore) == 1) {
    printf("Hai inserito: %d\n", valore);
}
else {
    printf("Input non valido\n");
}

Proteggere un'operazione

Prima di dividere, si controlla che il divisore non sia zero:

if (divisore != 0) {
    printf("Risultato: %d\n", dividendo / divisore);
}
else {
    printf("Errore: divisione per zero!\n");
}

Controllare un intervallo

float temperatura;
bool inputOk = scanf("%f", &temperatura) == 1;
// 0 <= temperatura_valida <= 100
if (inputOk && 0 <= temperatura && temperatura <= 100) {
    printf("Temperatura entro i limiti\n");
}
else {
    printf("Temperatura fuori intervallo o lettura errata\n");
}

Qui lavorano insieme tre idee della 03C: l'intervallo con due confronti, il cortocircuito che non guarda temperatura se la lettura è fallita, e una variabile bool con un nome chiaro. Ho provato: 25 e 100 sono entro i limiti; −3, 100.5 e ciao danno il secondo messaggio.

All'esame, su CodeRunner, quasi ogni esercizio ha degli if. Le cose da avere in mano:

1. compila con -Wall -Werror e leggi gli avvisi: = al posto di == e le graffe dimenticate vengono fermati qui;
2. int main(void), non void main();
3. niente switch, break e continue: le scelte si fanno con if ed else if;
4. prova i casi limite: lo zero, i numeri uguali, i valori sul confine tra due fasce (17 e 18, 5 e 6);
5. un else finale per i casi che non ti aspetti, come l'input non valido.

Negli esercizi sullo stato della memoria può comparire un if con una variabile dichiarata dentro: la sua casella esiste solo mentre il programma è nel blocco, e alla } si cancella.

Flusso di controllo

L'ordine in cui il programma esegue le istruzioni.

Programmazione strutturata

Scrivere i programmi solo con sequenza, selezione e iterazione.

Teorema di Böhm-Jacopini

Sequenza, selezione e iterazione bastano per qualunque algoritmo (1966).

Selezione

Scegliere quale blocco eseguire in base a una condizione.

if

Esegue un blocco solo se la condizione è vera.

else

Il blocco da eseguire quando la condizione è falsa.

else if

Una nuova condizione, controllata solo se le precedenti erano false.

Blocco

Istruzioni tra graffe; le variabili dichiarate dentro esistono solo lì.

Visibilità

La parte di programma in cui un nome di variabile si può usare.

Scambio condizionato

Scambiare due variabili solo se sono nell'ordine sbagliato.

Caso limite

Un valore sul confine tra due casi, dove gli errori si vedono meglio.

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

• So nominare le tre strutture e il teorema di Böhm-Jacopini.
• So scrivere if, if-else e una catena else if.
• So che in una catena si esegue un solo blocco, il primo con la condizione vera.
• So riconoscere = al posto di == e le graffe dimenticate.
• So mettere le condizioni dalla più specifica alla più generale.
• So che una variabile dichiarata in un blocco sparisce alla sua }.
• So scrivere lo scambio condizionato e seguirlo nella memoria.
• So scrivere senza pensarci il massimo, il controllo dell'input, la divisione protetta e l'intervallo.
• So scegliere i casi limite per provare un programma con gli if.