Les booléens en C : stdbool.h, _Bool et la véracité

Le C a passé ses 27 premières années sans type booléen. Ce n'est pas un oubli - c'est une décision de conception avec des conséquences que vous rencontrez dès le premier jour, et un bug célèbre qui en découle directement.

Zéro est faux, tout le reste est vrai

Il n'existe aucune valeur vrai/faux spéciale dans les règles de condition du C. if, while, for, &&, || et ! posent tous exactement une question : cette valeur est-elle nulle ?

#include <stdio.h>

int main(void) {
    if (1)    printf("1 est vrai\n");
    if (42)   printf("42 est vrai\n");
    if (-7)   printf("-7 est vrai\n");
    if (0.5)  printf("0.5 est vrai\n");

    if (0)    printf("ceci ne s'affiche jamais\n");
    if (0.0)  printf("ni ceci\n");

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

Les nombres négatifs sont vrais. Les fractions sont vraies. Un pointeur non nul est vrai. Seul zéro - dans n'importe quel type - est faux.

C'est pourquoi le code C regorge d'idiomes qui paraissent laconiques tant qu'on ignore la règle :

if (count)            /* si count n'est pas nul */
if (!count)           /* si count vaut zero */
if (p)                /* si p n'est pas NULL */
if (!strcmp(a, b))    /* si les chaines sont egales - strcmp renvoie 0 en cas d'egalite */

Le dernier piège les gens. strcmp renvoie 0 quand les chaînes correspondent, donc « égales » se lit « non » dans un if. Écrire if (strcmp(a, b) == 0) est plus clair et fait exactement la même chose.

Les comparaisons produisent un int

Une comparaison en C n'est pas une sorte spéciale d'expression. Elle s'évalue en un int ordinaire valant 1 ou 0, et vous pouvez l'afficher, la stocker ou faire de l'arithmétique avec :

#include <stdio.h>

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

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

    /* Compter en s'appuyant sur le fait qu'une comparaison vaut 1 ou 0 : */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* ajoute 1 si vrai, 0 si faux */
    }
    printf("%d sur 5 ont reussi\n", passed);
    return 0;
}

L'opérateur ! fonctionne de la même manière : il produit 1 si son opérande est nul et 0 sinon. Ainsi !!x est un idiome classique qui normalise n'importe quelle valeur à exactement 0 ou 1.

bool, true et false (C99)

C99 a ajouté un véritable type booléen appelé _Bool, et un en-tête qui lui donne un nom lisible :

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

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

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

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

<stdbool.h> est minuscule : il définit bool comme _Bool, true comme 1 et false comme 0. C'est tout l'en-tête. Mais l'utiliser rend l'intention visible d'une façon que int flag = 1; ne fera jamais.

_Bool a un comportement réellement distinct : il ne stocke que 0 ou 1. Affecter n'importe quelle valeur non nulle la convertit en exactement 1 :

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* converti en 1 */

    printf("int  contenant 42 : %d\n", as_int);
    printf("bool contenant 42 : %d\n", as_bool);   /* 1, pas 42 */

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

Il n'existe toujours pas de %b dans printf pour les booléens - affichez-les avec %d, ou convertissez-les vous-même en texte :

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

const char *yes_no(bool b) {
    return b ? "vrai" : "faux";
}

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

En C23, cela s'est encore simplifié : bool, true et false sont devenus de vrais mots-clés, donc l'inclusion n'est plus nécessaire. La plupart du code actuel vise encore C17, alors gardez le #include <stdbool.h>.

Renvoyer un booléen depuis une fonction

C'est là que bool justifie le plus clairement sa place :

#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 est un nombre pair dans l'intervalle.\n");
    }
    return 0;
}

Un type de retour bool indique à l'appelant ce que la valeur signifie. Un retour int depuis une fonction nommée check_file pourrait être un booléen, un compte ou un code d'erreur - et dans les conventions des bibliothèques C, c'est souvent le troisième, où 0 signifie succès. Nommer le type supprime la devinette.

Le bug = contre ==

Parce que l'affectation est une expression qui produit la valeur affectée, et parce que toute valeur non nulle est vraie, ceci compile :

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* affectation, pas comparaison */
        printf("Branche prise. x vaut maintenant %d\n", x);
    }

    printf("x = %d (le 10 d'origine a disparu)\n", x);
    return 0;
}

Deux choses ont mal tourné d'un coup. La condition a affecté 5 à x, détruisant sa valeur, puis a testé 5, qui est non nul, donc la branche s'est exécutée. Le programme n'a ni erreur ni avertissement par défaut.

Pire, la version avec 0 n'exécute jamais sa branche :

if (found = 0) { /* jamais prise - et found vaut maintenant 0 */ }

Trois défenses, par ordre d'utilité :

Compilez avec les avertissements. -Wall l'attrape :

warning: suggest parentheses around assignment used as truth value

Arriver à zéro avertissement est le vrai correctif ici, et cela coûte une option.

Écrivez la constante en premier. La « condition de Yoda » transforme la faute de frappe en erreur de compilation :

if (5 == x)   /* correct */
if (5 = x)    /* erreur : ce n'est pas une lvalue - le compilateur vous arrete */

Certaines équipes adorent, d'autres trouvent cela illisible ; les deux positions se défendent, mais cela fonctionne.

Soyez explicite quand c'est voulu. L'affectation dans une condition est réellement utile pour lire une entrée :

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

Les parenthèses supplémentaires autour de c = getchar() sont requises par la précédence, et elles signalent aussi que l'affectation est intentionnelle. C'est l'idiome - si votre affectation-dans-une-condition ne ressemble pas à cela, c'est probablement une faute de frappe.

Erreurs courantes avec les booléens

Comparer à true. if (flag == true) fonctionne avec stdbool.h, mais cela casse dès que flag est un int valant 42, car 42 == 1 est faux. Écrivez if (flag).

Comparaisons chaînées. if (0 < x < 10) est toujours vrai : 0 < x produit 0 ou 1, et les deux sont inférieurs à 10. Écrivez if (x > 0 && x < 10).

Bit à bit au lieu de logique. & et | ne sont pas && et ||. Ils n'évaluent pas en court-circuit, et ils combinent des bits :

#include <stdio.h>

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

    printf("a && b = %d\n", a && b);   /* 1 - les deux sont non nuls */
    printf("a &  b = %d\n", a & b);    /* 0 - 01 ET 10 n'ont aucun bit commun */
    return 0;
}

Les deux opérandes sont « vrais », et pourtant a & b vaut 0. Utiliser & là où vous vouliez && produit une condition fausse seulement pour certaines valeurs, le type de bug le plus difficile à trouver.

Comparer des flottants pour l'égalité. if (0.1 + 0.2 == 0.3) est faux. Comparez plutôt avec une tolérance - voir types de données pour comprendre pourquoi.