Booleani in C: stdbool.h, _Bool e valori di verità

C ha passato i suoi primi 27 anni senza un tipo booleano. Non è una svista: è una scelta di progettazione con conseguenze che incontri fin dal primo giorno, e da cui deriva direttamente un bug famoso.

Zero è falso, tutto il resto è vero

Le regole delle condizioni in C non prevedono alcun valore speciale vero/falso. if, while, for, &&, || e ! fanno tutti una sola domanda: questo valore è zero?

#include <stdio.h>

int main(void) {
    if (1)    printf("1 e' vero\n");
    if (42)   printf("42 e' vero\n");
    if (-7)   printf("-7 e' vero\n");
    if (0.5)  printf("0.5 e' vero\n");

    if (0)    printf("questo non viene mai stampato\n");
    if (0.0)  printf("e nemmeno questo\n");

    printf("fatto\n");
    return 0;
}

I numeri negativi sono veri. Le frazioni sono vere. Un puntatore non nullo è vero. Solo lo zero, di qualsiasi tipo, è falso.

Ecco perché il codice C è pieno di idiomi che sembrano criptici finché non conosci la regola:

if (count)            /* se count non è zero */
if (!count)           /* se count è zero */
if (p)                /* se p non è NULL */
if (!strcmp(a, b))    /* se le stringhe sono uguali: strcmp restituisce 0 se coincidono */

L'ultimo trae in inganno molte persone. strcmp restituisce 0 quando le stringhe coincidono, quindi in un if "uguali" si legge come una negazione. Scrivere if (strcmp(a, b) == 0) è più chiaro e fa esattamente la stessa cosa.

I confronti producono int

Un confronto in C non è un tipo speciale di espressione. Viene valutato come un normale int con valore 1 o 0, e puoi stamparlo, memorizzarlo o usarlo nei calcoli:

#include <stdio.h>

int main(void) {
    int a = 5, b = 8;

    int result = (a < b);
    printf("(a < b) vale %d\n", result);      /* 1 */
    printf("(a > b) vale %d\n", a > b);       /* 0 */
    printf("(a == 5) + (b == 8) = %d\n", (a == 5) + (b == 8));  /* 2 */

    /* Contare sfruttando il fatto che un confronto vale 1 o 0: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* aggiunge 1 se vero, 0 se falso */
    }
    printf("%d su 5 promossi\n", passed);
    return 0;
}

L'operatore ! funziona allo stesso modo: produce 1 se il suo operando è zero e 0 altrimenti. Quindi !!x è un idioma classico che normalizza qualsiasi valore a esattamente 0 o 1.

bool, true e false (C99)

C99 ha aggiunto un vero tipo booleano chiamato _Bool e un header che gli dà un nome leggibile:

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

int main(void) {
    bool is_ready = true;
    bool has_error = false;

    printf("is_ready  = %d\n", is_ready);    /* stampa 1 */
    printf("has_error = %d\n", has_error);   /* stampa 0 */

    if (is_ready && !has_error) {
        printf("Si procede.\n");
    }
    return 0;
}

<stdbool.h> è minuscolo: definisce bool come _Bool, true come 1 e false come 0. Tutto l'header è questo. Ma usarlo rende visibile l'intenzione in un modo in cui int flag = 1; non riesce mai a fare.

_Bool ha un comportamento davvero distinto: memorizza solo 0 o 1. Qualsiasi valore diverso da zero assegnato viene convertito esattamente in 1:

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* convertito in 1 */

    printf("int  che contiene 42: %d\n", as_int);
    printf("bool che contiene 42: %d\n", as_bool);   /* 1, non 42 */

    bool from_pointer = (void *)0;   /* NULL -> false */
    printf("bool da NULL:         %d\n", from_pointer);
    return 0;
}

In printf non esiste ancora un %b per i booleani: stampali con %d oppure convertili tu in testo:

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

const char *yes_no(bool b) {
    return b ? "vero" : "falso";
}

int main(void) {
    bool connected = true;
    printf("connesso: %s\n", yes_no(connected));
    printf("vuoto:    %s\n", yes_no(false));
    return 0;
}

In C23 è diventato ancora più semplice: bool, true e false sono diventate vere parole chiave, quindi l'include non è più necessario. La maggior parte del codice oggi punta ancora a C17, quindi tieni #include <stdbool.h>.

Restituire un booleano da una funzione

È qui che bool si guadagna il suo posto nel modo più evidente:

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

bool is_even(int n) {
    return n % 2 == 0;
}

bool is_in_range(int value, int low, int high) {
    return value >= low && value <= high;
}

int main(void) {
    printf("is_even(10)            = %d\n", is_even(10));
    printf("is_even(7)             = %d\n", is_even(7));
    printf("is_in_range(5, 1, 10)  = %d\n", is_in_range(5, 1, 10));
    printf("is_in_range(50, 1, 10) = %d\n", is_in_range(50, 1, 10));

    if (is_even(10) && is_in_range(10, 1, 20)) {
        printf("10 e' un numero pari nell'intervallo.\n");
    }
    return 0;
}

Un tipo di ritorno bool dice a chi chiama cosa significa il valore. Un tipo di ritorno int di una funzione chiamata check_file potrebbe essere un booleano, un conteggio o un codice di errore, e secondo le convenzioni delle librerie C spesso è il terzo, dove 0 significa successo. Dare un nome al tipo elimina l'incertezza.

Il bug = vs ==

Poiché l'assegnazione è un'espressione che restituisce il valore assegnato, e poiché qualsiasi valore diverso da zero è vero, questo compila:

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* assegnazione, non confronto */
        printf("Ramo eseguito. Ora x vale %d\n", x);
    }

    printf("x = %d (il 10 originale non c'e' piu')\n", x);
    return 0;
}

Sono andate storte due cose insieme. La condizione ha assegnato 5 a x, distruggendone il valore, e poi ha verificato 5, che è diverso da zero, quindi il ramo è stato eseguito. Il programma non ha errori e, di default, nemmeno avvisi.

Peggio ancora, la versione con 0 non esegue mai il suo ramo:

if (found = 0) { /* mai eseguito, e ora found vale 0 */ }

Tre difese, in ordine di utilità:

Compila con gli avvisi attivi. -Wall lo individua:

warning: suggest parentheses around assignment used as truth value

Arrivare a zero avvisi è la vera soluzione, e costa un solo flag.

Scrivi prima la costante. La "condizione Yoda" trasforma il refuso in un errore di compilazione:

if (5 == x)   /* corretto */
if (5 = x)    /* errore: non è un lvalue, il compilatore ti ferma */

Alcuni team la adorano e altri la trovano illeggibile; entrambe le posizioni sono difendibili, ma funziona.

Sii intenzionale quando lo vuoi davvero. Un'assegnazione dentro una condizione è davvero utile per leggere l'input:

int c;
while ((c = getchar()) != EOF) { ... }

Le parentesi in più attorno a c = getchar() sono necessarie per la precedenza e segnalano anche che l'assegnazione è voluta. Questo è l'idioma: se la tua assegnazione in una condizione non ha questo aspetto, probabilmente è un refuso.

Errori comuni con i booleani

Confrontare con true. if (flag == true) funziona con stdbool.h, ma si rompe appena flag è un int che contiene 42, perché 42 == 1 è falso. Scrivi if (flag).

Confronti concatenati. if (0 < x < 10) è sempre vero: 0 < x restituisce 0 o 1, ed entrambi sono minori di 10. Scrivi if (x > 0 && x < 10).

Operatori bit a bit al posto di quelli logici. & e | non sono && e ||. Non fanno valutazione a cortocircuito e combinano i bit:

#include <stdio.h>

int main(void) {
    int a = 1, b = 2;

    printf("a && b = %d\n", a && b);   /* 1: entrambi sono diversi da zero */
    printf("a &  b = %d\n", a & b);    /* 0: 01 AND 10 non hanno bit in comune */
    return 0;
}

Entrambi gli operandi sono "veri", eppure a & b vale 0. Usare & dove intendevi && produce una condizione sbagliata solo per certi valori, il tipo di bug più difficile da trovare.

Confrontare float per uguaglianza. if (0.1 + 0.2 == 0.3) è falso. Confronta invece con una tolleranza: vedi i tipi di dati per capire perché.