Em C, a representação de valores booleanos (verdadeiro e falso) pode ser feita de algumas maneiras, dependendo do padrão C utilizado e da preferência do programador. Essencialmente, um tipo booleano em C é uma forma de um tipo inteiro, onde 0 representa falso e qualquer valor diferente de zero representa verdadeiro.

Existem três abordagens principais:

1. Usando macros pré-definidas (Padrão C89): Esta é a abordagem mais antiga, que utiliza a diretiva de pré-processador #define para criar um tipo e constantes para verdadeiro e falso.
2. Utilizando o tipo _Bool (Padrão C99): O padrão C99 introduziu o tipo _Bool como um tipo nativo para representar valores boolenaos.
3. Incluindo o cabeçalho <stdbool.h> (Padrão C99): Esta é a forma moderna e recomendada em C99 e posteriores, que define o tipo bool e as constantes true e false.

1. Abordagem com Macros (Padrão C89)

Nesta abordagem, definimos um alias para int e criamos macros para representar TRUE e FALSE. É importante notar que TRUE e FALSE são apenas nomes de identificadores para os valores 1 e 0, respectivamente.

#define BOOL int
#define TRUE 1
#define FALSE 0

Variáveis declaradas com o tipo BOOL podem ser reatribuídas com qualquer valor inteiro. No entanto, para fins de avaliação booleana (em condicionais, por exemplo), a regra de 0 ser falso e não-zero ser verdadeiro sempre se aplicará.

2. Abordagem com _Bool (Padrão C99)

O tipo _Bool é um tipo inteiro que pode armazenar apenas os valores 0 e 1. Qualquer valor não-zero atribuído a uma variável _Bool será automaticamente convertido para 1.

_Bool flag = -5; // flag agora é 1
_Bool status = 0; // status é 0

3. Abordagem com <stdbool.h> (Padrão C99)

Esta é a maneira mais idiomática e legível de trabalhar com booleanos em C moderno. Incluir o cabeçalho <stdbool.h> define o tipo bool e as constantes true e false, que se comportam de maneira semelhante ao tipo _Bool.

#include <stdbool.h>

bool is_active = true;
bool is_valid = false;

Assim como com _Bool, atribuir um valor não-zero a uma variável bool resultará em 1, e artibuir 0 resultará em 0.

Exemplos Práticos

Exemplo 1: Usando Macros

#include <stdio.h>

#define BOOL int
#define TRUE 1
#define FALSE 0

int main() {
    BOOL is_ready = TRUE;
    BOOL has_error = FALSE;

    // Modificando o valor de has_error. Qualquer valor não-zero será tratado como TRUE.
    has_error = -10; 

    printf("is_ready: %d, has_error: %d\n", is_ready, has_error);

    if (is_ready) {
        printf("Sistema está pronto.\n");
    } else {
        printf("Sistema não está pronto.\n");
    }

    if (has_error) {
        printf("Ocorreu um erro.\n");
    } else {
        printf("Sem erros.\n");
    }

    return 0;
}

Exemplo 2: Usando _Bool

#include <stdio.h>

int main() {
    _Bool is_enabled = 1;
    _Bool is_disabled = 0;

    // Modificando o valor de is_disabled. -7 será convertido para 1.
    is_disabled = -7; 

    printf("is_enabled: %d, is_disabled: %d\n", is_enabled, is_disabled);

    if (is_enabled) {
        printf("Funcionalidade está habilitada.\n");
    } else {
        printf("Funcionalidade está desabilitada.\n");
    }

    if (is_disabled) {
        printf("Estado é 'desabilitado' (representado por 1).\n");
    } else {
        printf("Estado é 'desabilitado' (representado por 0).\n");
    }

    return 0;
}

Exemplo 3: Usando <stdbool.h>

#include <stdio.h>
#include <stdbool.h> // Necessário para usar bool, true, false

int main() {
    bool is_valid_data = true;
    bool is_empty = false;

    // Atribuindo um valor não-zero a is_empty. Será convertido para true (1).
    is_empty = 99; 

    printf("is_valid_data: %d, is_empty: %d\n", is_valid_data, is_empty);

    if (is_valid_data) {
        printf("Dados são válidos.\n");
    } else {
        printf("Dados são inválidos.\n");
    }

    if (is_empty) {
        printf("O campo está preenchido (interpretado como true).\n");
    } else {
        printf("O campo está vazio (interpretado como false).\n");
    }

    return 0;
}

Embora todas as três abordagens funcionem, o uso de <stdbool.h> é o mais recomendado por sua clareza e conformidade com padrões modernos.