Espressioni booleane, il tipo bool e gli operatori logici

Pensa al tornello della metropolitana. Avvicini il biglietto, e il tornello si fa una domanda: «il biglietto è valido?». Se la risposta è sì si apre, se è no resta chiuso. Il tornello non fa conti difficili: risponde a una domanda con un sì o con un no, e poi sceglie che cosa fare.

Anche un programma fa così. Finora i nostri programmi eseguivano le istruzioni una dopo l'altra, sempre tutte. Ma un programma vero deve decidere, e per decidere deve farsi domande come queste, che vengono dalle slide:

• «Ho già fatto tutte le somme richieste?», come nella moltiplicazione della lezione 01A;
• «L'input scritto da tastiera è corretto?»;
• «Lo studente ha superato l'esame?».

Le espressioni booleane sono il modo di scrivere queste domande in C. Sono il ponte tra i dati, che sono numeri, e le scelte. In questa lezione impari a scriverle; nella 03D le usi per scegliere che cosa fare, con if.

La domanda più semplice confronta due numeri: «il voto è almeno 18?». In C si scrive voto >= 18. Il risultato non è un sì scritto a parole: è un numero, 1 se la risposta è sì e 0 se è no.

Si chiamano operatori relazionali, perché dicono in che relazione stanno due valori. Gli esempi delle slide:

• contatore != n: le ripetizioni non sono ancora finite;
• pinInserito == pinCorretto: il PIN è giusto;
• temperatura <= limiteMax: la temperatura non supera il limite;
• voto >= 18: l'esame è superato.

>= e <= si scrivono con il segno di uguale dopo: => e =< non esistono in C.

Per tenere la risposta a una domanda serve una variabile. Il C più vecchio usava gli int, con questa regola, che vale ancora oggi:

• 0 vuol dire falso;
• qualunque altro numero vuol dire vero.

Dal 1999, cioè dalla versione del C chiamata C99, esiste un tipo apposta. Si usa scrivendo in cima al programma:

#include <stdbool.h>

e porta tre cose: il tipo bool e le due costanti true, che vale 1, e false, che vale 0. Il nome viene da George Boole, il matematico che nell'Ottocento ha studiato la logica del vero e del falso. Le slide chiedono di usare bool ogni volta che si può: chi legge capisce subito che la variabile contiene un sì o un no.

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int votoScritto = 25;
    int sogliaSuff = 18;
    bool superato = votoScritto >= sogliaSuff;
    printf("Lo studente supera l'esame? %d\n", superato);
}

Lo studente supera l'esame? 1

La riga bool superato = votoScritto >= sogliaSuff; funziona come ogni assegnamento: prima si calcola la destra, 25 >= 18, che vale 1, poi il risultato si copia in superato.

Per bool non c'è uno specificatore di printf: si usa %d, come per gli interi, e si vede 0 oppure 1.

Se metti in un bool un numero diverso da 0 e 1, diventa true: con bool c = 5;, printf("%d", c) stampa 1.

Spesso una sola domanda non basta. Il login di un sito riesce se hai fatto meno di 3 tentativi e l'account non è bloccato. Il biglietto è scontato se hai meno di 12 anni oppure sei tesserato. Per unire le domande ci sono tre operatori logici:

Gli esempi delle slide, riscritti con i nomi delle variabili:

bool login = (numTentativi < 3) && !accountBloccato;
bool riscaldamento = (temperatura < 18) && termostatoOn;
bool sconto = (eta < 12) || tesserato;
bool ventolaAccesa = (temperatura >= 28) || modoManuale;

Il primo si legge: «login è vero se i tentativi sono meno di 3 e l'account non è bloccato».

Le tavole di verità

Una tavola di verità scrive il risultato per tutte le combinazioni possibili. Con due domande le combinazioni sono quattro.

• && dà 1 in una sola riga, quella con tutti e due a 1.
• || dà 0 in una sola riga, quella con tutti e due a 0.
• L'«o» del C è inclusivo: se sono vere tutte e due, il risultato è vero.

Sono le stesse tavole della lezione 06 di Fondamenti, con 1 e 0 al posto di V e F.

Prova a scrivere una formula e a vederne la tavola. Qui si usano le lettere per le domande, & o && per «e», | o || per «o», ! per «non»:

Un esempio di tutti i giorni: «ho tra 18 e 30 anni». In matematica si scrive in modo compatto, $18\le x\le 30$. In C questa scrittura non funziona: bisogna spezzarla in due confronti uniti da &&.

18 <= x && x <= 30

Si legge: «18 è minore o uguale a x, e x è minore o uguale a 30». È la forma più vicina a quella della matematica: x sta in mezzo, e i due estremi ai lati.

Le slide avvertono che il secondo, a <= x && x < b, si userà moltissimo: è il controllo che un indice stia dentro un array, che vedrai più avanti.

Per il contrario, «x è fuori da $[18,30]$», si usa ||: x < 18 || x > 30. Basta che sia vera una delle due.

Torna al tornello. Se il biglietto è scaduto, il tornello resta chiuso: non ha bisogno di controllare anche se è il biglietto giusto per quella linea. Il C fa la stessa cosa. Le parti di un && o di un || si calcolano da sinistra a destra, e il calcolo si ferma appena il risultato è sicuro.

• In a && b, se a è falsa il risultato è falso comunque: b non viene calcolata.
• In a || b, se a è vera il risultato è vero comunque: b non viene calcolata.

Si chiama valutazione in cortocircuito, in inglese short-circuit evaluation. Non è solo un risparmio di tempo: serve a proteggere la seconda parte.

bool condizione = (divisore != 0) && ((numeratore / divisore) > 5);

Se divisore vale 0, la prima parte è falsa e la divisione non viene mai fatta. Senza cortocircuito il programma si fermerebbe con una divisione per zero, un errore a runtime della lezione 02A. Ho provato con numeratore = 40: con divisore = 0 la condizione vale 0 e il programma va avanti; con divisore = 4 vale 1, perché 40 / 4 = 10 è maggiore di 5.

L'ordine conta: scritto al contrario, (numeratore / divisore > 5) && (divisore != 0), la divisione si farebbe prima del controllo.

Con scanf

int valore;
bool scanPari = (scanf("%d", &valore) == 1) && (valore % 2 == 0);

Ricordi dalla 02C che scanf restituisce quanti valori ha letto. Se l'input non è un numero, scanf restituisce 0 e valore resta «?»: grazie al cortocircuito, quel valore senza senso non viene mai guardato.

Il programma completo della slide 18 fa tre domande sullo stesso numero:

#include <stdio.h>
#include <stdbool.h>

int main(void) {
    int numero;
    bool letto, positivo, dispari;
    printf("Inserisci un numero intero: ");
    letto = (scanf("%d", &numero) == 1); // true se scanf ha letto correttamente
    positivo = letto && (numero > 0);      // input valido e maggiore di 0
    dispari  = letto && (numero % 2 != 0); // input valido e non divisibile per 2
    // stampa i risultati (0 = falso, 1 = vero)
    printf("Input valido? %d\n", letto);
    printf("Numero positivo? %d\n", positivo);
    printf("Numero dispari? %d\n", dispari);
}

Con 3.9 la scanf legge il 3 e si ferma al punto, come nella 02C: per lei l'input è valido.

Quando && e || si mescolano, una condizione diventa difficile da leggere e facile da sbagliare. L'esempio delle slide:

bool sconto = registrato && spesaTotale >= 100 ||
              (codiceNonScaduto && attivatoDallUtente);

Le slide propongono di spezzarla in variabili bool intermedie, con nomi che dicono che cosa controllano:

bool clientePremium = registrato && (spesaTotale >= 100);
bool promoExtra     = codiceNonScaduto && attivatoDallUtente;
bool sconto         = clientePremium || promoExtra;

L'ultima riga ora si legge come una frase: «c'è lo sconto se il cliente è premium oppure c'è la promozione».

L'ordine delle operazioni

Senza parentesi, il C calcola in quest'ordine, dal primo all'ultimo:

Per questo numero % 2 != 0 funziona senza parentesi: prima il resto, poi il confronto. E a || b && c vuol dire a || (b && c), perché && viene prima. Non serve ricordare la tabella a memoria: nel dubbio, metti le parentesi.

A volte la domanda serve solo a scegliere tra due valori: «se x è pari prendi 100, altrimenti 200». Per questo il C ha un operatore con tre pezzi, l'operatore ternario:

condizione ? valore_se_vero : valore_se_falso

Si legge: «la condizione è vera? Allora questo, altrimenti quello». L'esempio delle slide:

int x = 5;
int y = (x % 2 == 0) ? 100 : 200;  // y = 200, perché x è dispari

Altri due usi tipici, provati:

int massimo = (a > b) ? a : b;
printf("%s\n", voto >= 18 ? "promosso" : "bocciato");

Con a = 3 e b = 8, massimo vale 8. %s stampa un testo: lo vedrai con le stringhe.

Le slide consigliano il ternario solo per scelte piccole e chiare. Quando la scelta è più complicata, o deve eseguire istruzioni e non solo scegliere un valore, si usa if…else, nella 03D.

All'esame le condizioni sono dappertutto: per decidere che cosa fare con if, per fermare un ciclo con while, per controllare un indice. Gli errori tipici che fanno perdere punti, o che fanno fallire la compilazione su CodeRunner con -Wall -Werror:

1. = al posto di ==: con -Wall -Werror dentro un if non compila, ma in un'altra posizione può passare e dare un risultato sbagliato;
2. intervalli scritti come in matematica: 0 <= x <= 10 non compila con -Werror;
3. && e || mescolati senza parentesi: avviso di gcc, quindi errore con -Werror;
4. l'ordine sbagliato nei controlli che proteggono: prima divisore != 0, poi la divisione; prima l'indice dentro l'intervallo, poi l'elemento;
5. % 2 == 1 per i dispari: sbagliato con i negativi.

Più avanti, negli esercizi sulla correttezza dei programmi, scriverai condizioni dentro assert: lì serve saper scrivere e negare una condizione senza errori.

Espressione booleana

Un'espressione con risposta vero o falso; in C vale 1 o 0.

Operatore relazionale

==, !=, <, >, <=, >=: confronta due valori.

bool

Tipo con due valori, true e false, da stdbool.h; occupa un byte.

true, false

Le costanti vero (1) e falso (0) di stdbool.h.

&& (AND)

Vero quando sono vere tutte e due le parti.

|| (OR)

Vero quando è vera almeno una parte.

! (NOT)

Rovescia vero e falso.

Tavola di verità

Tabella con il risultato per ogni combinazione di vero e falso.

Cortocircuito

Il calcolo di && o || si ferma appena il risultato è sicuro.

Operatore ternario

condizione ? a : b, vale a se la condizione è vera, b se è falsa.

Leggi di De Morgan

Il contrario di un AND è l'OR dei contrari, e viceversa.

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

• So che un confronto in C vale 1 o 0.
• Non confondo = e ==.
• So usare bool, true e false con stdbool.h, e stampare un bool con %d.
• So le tavole di verità di &&, || e !.
• So scrivere un intervallo chiuso, aperto o semiaperto con due confronti.
• So perché 0 <= x <= 10 è sempre vero.
• So spiegare il cortocircuito e mettere per primo il controllo che protegge.
• So spezzare una condizione lunga in variabili bool con un nome.
• So negare una condizione con De Morgan.
• So usare l'operatore ternario per scegliere tra due valori.