C Standard Library stdbool.h

What You’ll Learn

Before C99, C had no built-in bool keyword in everyday code—programmers used int with 0 and 1. <stdbool.h> (C99) adds bool, true, and false so conditions read clearly and match other languages.

Definition and Usage

bool is a macro that expands to _Bool, a type that holds only two values: 0 (false) and 1 (true). Assigning any non-zero integer to a _Bool stores 1.

true and false are macros for integer constants 1 and 0. Use them for initialization and return values so intent is obvious. In if conditions, write if (flag) rather than if (flag == true).

📝 Syntax

Include the header:

#include <stdbool.h>

What stdbool.h defines

• bool — macro for _Bool.
• true — macro for 1.
• false — macro for 0.
• __bool_true_false_are_defined — feature-test macro (C99).

Common usage

bool ready = false;
bool is_valid = true;

bool check(int x) {
    return x > 0;   /* expression converts to 0 or 1 */
}

if (ready) { /* ... */ }
if (!is_valid) { /* ... */ }

Headers and linking

• #include <stdbool.h> — macros only, no link flag.
• Compile: gcc program.c -std=c11 -o program (C99 or later).
• C++ has built-in bool; do not assume C++ headers define C bool the same way in mixed code.

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Every example needs #include <stdbool.h>.

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

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

int main(void) {
    int num = 4;

    if (is_even(num)) {
        printf("%d is even.\n", num);
    } else {
        printf("%d is odd.\n", num);
    }

    printf("is_even(7) stores as int value: %d\n", is_even(7));

    return 0;
}

4 is even.
is_even(7) stores as int value: 0

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

bool is_positive(int x) {
    return x > 0;
}

int main(void) {
    int values[] = { -3, 0, 42 };
    size_t i;

    for (i = 0; i < 3; i++) {
        if (is_positive(values[i])) {
            printf("%d is positive\n", values[i]);
        } else {
            printf("%d is not positive\n", values[i]);
        }
    }

    return 0;
}

-3 is not positive
0 is not positive
42 is positive

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

int main(void) {
    bool lights_on = false;

    printf("Start: %s\n", lights_on ? "on" : "off");

    lights_on = true;
    printf("After set true: %s\n", lights_on ? "on" : "off");

    lights_on = !lights_on;
    printf("After toggle: %s\n", lights_on ? "on" : "off");

    return 0;
}

Start: off
After set true: on
After toggle: off

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

enum { FLAG_WIFI, FLAG_BLUETOOTH, FLAG_GPS, FLAG_COUNT };

int main(void) {
    bool features[FLAG_COUNT] = { true, false, true };
    const char *names[] = { "WiFi", "Bluetooth", "GPS" };
    size_t i;

    for (i = 0; i < FLAG_COUNT; i++) {
        printf("%s: %s\n", names[i], features[i] ? "enabled" : "disabled");
    }

    return 0;
}

WiFi: enabled
Bluetooth: disabled
GPS: enabled

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

int main(void) {
    bool flag;

    flag = 0;
    printf("assign 0  -> flag = %d\n", flag);

    flag = 42;
    printf("assign 42 -> flag = %d\n", flag);

    flag = -1;
    printf("assign -1 -> flag = %d\n", flag);

    return 0;
}

assign 0  -> flag = 0
assign 42 -> flag = 1
assign -1 -> flag = 1

🚀 Common Use Cases

• Predicate functions — is_valid, has_permission, contains.
• State flags — bool connected, bool debug_mode.
• Loop conditions — while (running) with bool running.
• Search results — return true when an item is found.
• Config options — enable/disable features in settings structs.
• Readability — clearer than magic int 0/1 in modern C99+ code.

📝 Notes

• C99 feature—use -std=c99, c11, or newer.
• bool promotes to int in expressions like other small integers.
• sizeof(bool) is typically 1 byte but is implementation-defined.
• Do not redefine true/false in your own headers.
• printf("%d", flag) prints 0 or 1; there is no %b in standard C.
• In C++, bool is a keyword—no need for stdbool.h in C++ files.

⚡ Optimization

bool is as cheap as a small integer. For huge arrays of flags, bit-packing into unsigned int masks saves memory but adds complexity. For clarity and typical programs, bool is fine.

💡 Best Practices