Decisioni

if ed else

La forma di una decisione

La lezione Dal problema all’algoritmo ha presentato tre forme con cui si costruisce ogni algoritmo: la sequenza, la decisione e la ripetizione. Finora i programmi del corso sono stati sequenze, salvo qualche if anticipato nell’unità 1; questa lezione scrive in C++ la seconda forma. Una decisione valuta una condizione, cioè un’espressione di tipo bool come quelle della lezione Relazioni e logica, ed esegue un blocco se la condizione è vera e un altro se è falsa:

if (condizione) {    // si esegue se la condizione è vera} else {    // si esegue se la condizione è falsa}

La condizione va sempre tra parentesi. La parte else è facoltativa: senza di essa, se la condizione è falsa non si fa nulla e il programma prosegue con l’istruzione successiva alla decisione. In entrambi i casi i due cammini si riuniscono alla fine, così che la decisione, vista dall’esterno, è una sola istruzione con un ingresso e un’uscita, come esigeva la lezione 1.1.

#include <iostream>#include <print>​int main(){    int a{};    int b{};    std::cin >> a >> b;    int r{a % b};    if (r < 0) {        r = r + b;    }    std::println("Resto euclideo di {} diviso {}: {}", a, b, r);}

-7 2

Resto euclideo di -7 diviso 2: 1

Con else, la decisione sceglie tra due azioni che si escludono. La condizione di anno bisestile della lezione Relazioni e logica produce un bool; una decisione lo trasforma in un comportamento del programma.

#include <iostream>#include <print>​int main(){    int year{};    std::cin >> year;    const bool isLeap{(year % 4 == 0 && year % 100 != 0) || year % 400 == 0};    if (isLeap) {        std::println("{} è bisestile: febbraio ha 29 giorni.", year);    } else {        std::println("{} non è bisestile: febbraio ha 28 giorni.", year);    }}

1900

1900 non è bisestile: febbraio ha 28 giorni.

Dare un nome alla condizione, come isLeap, separa ciò che si decide da ciò che si fa con la decisione.

Sempre le graffe

La grammatica di C++ permette di omettere le parentesi graffe quando il blocco ha una sola istruzione: if (r < 0) r = r + b; è valido. Ora, senza graffe la decisione governa solo l’istruzione successiva, e ciò che il lettore crede governato dipende dall’indentazione, che il compilatore ignora. Se è così, ogni modifica successiva (aggiungere una seconda istruzione, commentare la prima) può cambiare il significato senza che il testo lo mostri. Ne segue la regola del corso: il blocco di un if o di un else porta sempre le graffe, anche se contiene una sola istruzione.

L’errore più breve di tutti conferma la regola. Un punto e virgola dopo le parentesi è un’istruzione vuota, e la decisione governa quell’istruzione vuota; il blocco che segue non appartiene più all’if e si esegue sempre.

#include <print>​int main(){    const int stock{12};    if (stock == 0);    {        std::println("Prodotto esaurito");    }    std::println("Unità disponibili: {}", stock);}

main.cpp: In function ‘int main()’:main.cpp:6:20: warning: suggest braces around empty body in an ‘if’ statement [-Wempty-body]    6 |     if (stock == 0);      |                    ^main.cpp:6:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]    6 |     if (stock == 0);      |     ^~main.cpp:7:5: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’    7 |     {      |     ^

Prodotto esauritoUnità disponibili: 12

Il programma annuncia che il prodotto è esaurito benché restino 12 unità. GCC dà due avvisi: -Wempty-body suggerisce le graffe attorno al corpo vuoto, e -Wmisleading-indentation segnala che il blocco è indentato come se l’if lo governasse. L’altro errore classico, if (x = 0) invece di if (x == 0), è stato visto nella lezione Compilare, eseguire e configurare: l’assegnamento vale zero, che si converte in false, e -Wparentheses avvisa. In entrambi i casi il programma compila; senza gli avvisi, l’errore passerebbe inosservato.

Le graffe hanno una conseguenza in più: una variabile dichiarata dentro il blocco di un if esiste solo lì. Se un valore calcolato in un ramo si usa dopo la decisione, la variabile si dichiara prima, come r nell’esempio del resto; l’ambito di visibilità sarà studiato nella lezione Parametri e ambito di visibilità.

L’operatore condizionale

Quando i due rami di una decisione si limitano a scegliere un valore, C++ offre una forma più breve: condizione ? a : b vale a se la condizione è vera e b se è falsa, e valuta solo l’elemento scelto. A differenza di if, che è un’istruzione, l’operatore condizionale è un’espressione: ha un valore e un tipo, e può stare dove sta qualsiasi espressione, per esempio nell’inizializzazione di una costante, che un if non permetterebbe senza rinunciare a const.

#include <iostream>#include <print>​int main(){    int a{};    int b{};    std::cin >> a >> b;    const int larger{a > b ? a : b};    std::println("Maggiore: {}", larger);    std::println("{} {}", b, b == 1 ? "pezzo" : "pezzi");    const auto mixed{a > b ? a : 0.5};    std::println("Tipo comune: {:.1f}", mixed);    std::println("Senza parentesi: {}", 10 + a > b ? 1 : 0);    std::println("Con parentesi: {}", 10 + (a > b ? 1 : 0));}

7 3

Maggiore: 73 pezziTipo comune: 7.0Senza parentesi: 1Con parentesi: 11

Le prime due righe mostrano l’uso che chiarisce: scegliere il maggiore e accordare una parola con il numero, senza ripetere l’istruzione intera in due rami. La terza mostra che l’espressione ha un solo tipo, qualunque sia il ramo scelto: se i due risultati sono di tipi diversi, si convertono in un tipo comune con le conversioni aritmetiche usuali della lezione Aritmetica; qui, un int e un double danno double, e il 7 scelto si conserva come 7.0. Le ultime due mostrano la precedenza: l’operatore condizionale è tra quelli di priorità più bassa, così che senza parentesi la condizione è 10 + a > b e il valore, 1, invece di 11. Quando il condizionale fa parte di un’espressione più grande, va tra parentesi.

L’operatore oscura non appena gli si chiede più che scegliere un valore. Annidato, come in a > b ? (a > c ? a : c) : (b > c ? b : c), costringe a ricostruire mentalmente una decisione annidata senza le graffe che la rendono leggibile; e usato per i suoi effetti, come in ok ? std::println("sì") : std::println("no"), è un if travestito. La regola del corso è usarlo solo per scegliere tra due valori brevi, senza annidarlo; tutto il resto si scrive con if.