Booleanos em C: stdbool.h, _Bool e veracidade

C passou seus primeiros 27 anos sem um tipo booleano. Isso não é um descuido - é uma decisão de projeto com consequências que você encontra no seu primeiro dia, e um bug famoso que decorre diretamente dela.

Zero é falso, todo o resto é verdadeiro

Não existe um valor especial de verdadeiro/falso nas regras de condição do C. if, while, for, &&, || e ! fazem exatamente uma pergunta: este valor é zero?

#include <stdio.h>

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

    if (0)    printf("isto nunca é impresso\n");
    if (0.0)  printf("nem isto\n");

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

Números negativos são verdadeiros. Frações são verdadeiras. Um ponteiro não nulo é verdadeiro. Apenas zero - em qualquer tipo - é falso.

É por isso que o código C é cheio de idiomas que parecem lacônicos até você conhecer a regra:

if (count)            /* se count não for zero */
if (!count)           /* se count for zero */
if (p)                /* se p não for NULL */
if (!strcmp(a, b))    /* se as strings forem iguais - strcmp retorna 0 quando casam */

Esse último pega as pessoas. strcmp retorna 0 quando as strings casam, então "igual" se lê como "não" dentro de um if. Escrever if (strcmp(a, b) == 0) é mais claro e faz exatamente a mesma coisa.

Comparações produzem int

Uma comparação em C não é um tipo especial de expressão. Ela avalia para um int comum com o valor 1 ou 0, e você pode imprimi-la, armazená-la ou fazer aritmética com ela:

#include <stdio.h>

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

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

    /* Contando com o fato de que uma comparação é 1 ou 0: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* soma 1 quando verdadeiro, 0 quando falso */
    }
    printf("%d de 5 passaram\n", passed);
    return 0;
}

O operador ! funciona da mesma forma: produz 1 se seu operando for zero e 0 caso contrário. Então !!x é um idioma clássico que normaliza qualquer valor para exatamente 0 ou 1.

bool, true e false (C99)

C99 adicionou um tipo booleano de verdade chamado _Bool, e um cabeçalho que lhe dá um nome legível:

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

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

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

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

<stdbool.h> é minúsculo: ele define bool como _Bool, true como 1 e false como 0. É o cabeçalho inteiro. Mas usá-lo torna a intenção visível de um jeito que int flag = 1; nunca faz.

_Bool tem um comportamento genuinamente distinto: ele armazena apenas 0 ou 1. Atribuir qualquer valor diferente de zero converte para exatamente 1:

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* convertido para 1 */

    printf("int  guardando 42: %d\n", as_int);
    printf("bool guardando 42: %d\n", as_bool);   /* 1, não 42 */

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

Ainda não existe um %b no printf para booleanos - imprima-os com %d, ou converta para texto você mesmo:

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

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

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

No C23 isso ficou ainda mais simples: bool, true e false viraram palavras-chave de verdade, então o include não é mais obrigatório. A maior parte do código hoje ainda mira C17, então mantenha o #include <stdbool.h>.

Retornando um booleano de uma função

É aqui que bool justifica seu lugar de forma mais clara:

#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 é um número par dentro da faixa.\n");
    }
    return 0;
}

Um tipo de retorno bool diz a quem chama o que o valor significa. Um retorno int de uma função chamada check_file poderia ser um booleano, uma contagem ou um código de erro - e nas convenções das bibliotecas C é frequentemente o terceiro, em que 0 significa sucesso. Nomear o tipo elimina o palpite.

O bug de = vs ==

Como a atribuição é uma expressão que resulta no valor atribuído, e como qualquer valor diferente de zero é verdadeiro, isto compila:

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* atribuição, não comparação */
        printf("Ramo executado. x agora é %d\n", x);
    }

    printf("x = %d (o 10 original se foi)\n", x);
    return 0;
}

Duas coisas deram errado de uma vez. A condição atribuiu 5 a x, destruindo seu valor, e então testou 5, que é diferente de zero, então o ramo executou. O programa não tem erro nem aviso por padrão.

Pior, a versão com 0 nunca executa seu ramo:

if (found = 0) { /* nunca executa - e found agora é 0 */ }

Três defesas, em ordem de utilidade:

Compile com avisos. -Wall pega isso:

warning: suggest parentheses around assignment used as truth value

Chegar a zero avisos é a verdadeira solução aqui, e custa uma flag.

Escreva a constante primeiro. A "condição Yoda" transforma o erro de digitação em um erro de compilação:

if (5 == x)   /* correto */
if (5 = x)    /* erro: não é um lvalue - o compilador te impede */

Alguns times adoram isso e outros acham ilegível; qualquer posição é defensável, mas funciona.

Seja deliberado quando for intencional. A atribuição dentro de uma condição é genuinamente útil para ler entrada:

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

Os parênteses extras em torno de c = getchar() são exigidos por precedência, e também sinalizam que a atribuição é intencional. Esse é o idioma - se a sua atribuição dentro de uma condição não se parece com isso, provavelmente é um erro de digitação.

Erros comuns com booleanos

Comparar com true. if (flag == true) funciona com stdbool.h, mas quebra no momento em que flag é um int guardando 42, porque 42 == 1 é falso. Escreva if (flag).

Comparações encadeadas. if (0 < x < 10) é sempre verdadeiro: 0 < x resulta em 0 ou 1, e ambos são menores que 10. Escreva if (x > 0 && x < 10).

Bit a bit em vez de lógico. & e | não são && e ||. Eles não fazem curto-circuito, e combinam bits:

#include <stdio.h>

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

    printf("a && b = %d\n", a && b);   /* 1 - ambos são diferentes de zero */
    printf("a &  b = %d\n", a & b);    /* 0 - 01 AND 10 não tem bits em comum */
    return 0;
}

Ambos os operandos são "verdadeiros" e, ainda assim, a & b é 0. Usar & onde você queria && produz uma condição que só está errada para certos valores, que é o tipo de bug mais difícil de encontrar.

Comparar floats por igualdade. if (0.1 + 0.2 == 0.3) é falso. Compare contra uma tolerância - veja tipos de dados para entender o porquê.