Booleans in C: stdbool.h, _Bool, and Truthiness

C spent its first 27 years without a boolean type. That is not an oversight - it is a design decision with consequences you meet on your first day, and one famous bug that follows directly from it.

Zero Is False, Everything Else Is True

There is no special true/false value in C's condition rules. if, while, for, &&, ||, and ! all ask exactly one question: is this value zero?

#include <stdio.h>

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

    if (0)    printf("this never prints\n");
    if (0.0)  printf("nor this\n");

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

Negative numbers are true. Fractions are true. A non-null pointer is true. Only zero - in any type - is false.

This is why C code is full of idioms that look terse until you know the rule:

if (count)            /* if count is not zero */
if (!count)           /* if count is zero */
if (p)                /* if p is not NULL */
if (!strcmp(a, b))    /* if the strings are equal - strcmp returns 0 for a match */

That last one catches people. strcmp returns 0 when the strings match, so "equal" reads as "not" in an if. Writing if (strcmp(a, b) == 0) is clearer and does exactly the same thing.

Comparisons Produce int

A comparison in C is not a special kind of expression. It evaluates to an ordinary int with the value 1 or 0, and you can print it, store it, or do arithmetic with it:

#include <stdio.h>

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

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

    /* Counting with the fact that a comparison is 1 or 0: */
    int scores[] = {45, 78, 92, 60, 88};
    int passed = 0;
    for (int i = 0; i < 5; i++) {
        passed += (scores[i] >= 60);   /* adds 1 when true, 0 when false */
    }
    printf("%d of 5 passed\n", passed);
    return 0;
}

The ! operator works the same way: it produces 1 if its operand is zero and 0 otherwise. So !!x is a classic idiom that normalizes any value to exactly 0 or 1.

bool, true, and false (C99)

C99 added a real boolean type called _Bool, and a header that gives it a readable name:

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

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

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

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

<stdbool.h> is tiny: it defines bool as _Bool, true as 1, and false as 0. That is the whole header. But using it makes intent visible in a way that int flag = 1; never does.

_Bool has one genuinely distinct behavior: it stores only 0 or 1. Assigning any non-zero value converts to exactly 1:

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

int main(void) {
    int    as_int  = 42;
    bool   as_bool = 42;      /* converted to 1 */

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

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

There is still no %b in printf for booleans - print them with %d, or convert to text yourself:

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

const char *yes_no(bool b) {
    return b ? "true" : "false";
}

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

In C23 this got simpler still: bool, true, and false became real keywords, so the include is no longer required. Most code today still targets C17, so keep the #include <stdbool.h>.

Returning a Boolean From a Function

This is where bool earns its place most clearly:

#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 is an even number in range.\n");
    }
    return 0;
}

A bool return type tells the caller what the value means. An int return type from a function called check_file could be a boolean, a count, or an error code - and in C library conventions it is often the third, where 0 means success. Naming the type removes the guess.

The = vs == Bug

Because assignment is an expression that yields the assigned value, and because any non-zero value is true, this compiles:

#include <stdio.h>

int main(void) {
    int x = 10;

    if (x = 5) {                     /* assignment, not comparison */
        printf("Branch taken. x is now %d\n", x);
    }

    printf("x = %d (the original 10 is gone)\n", x);
    return 0;
}

Two things went wrong at once. The condition assigned 5 to x, destroying its value, and then tested 5, which is non-zero, so the branch ran. The program has no error and no warning by default.

Worse, the version with 0 never runs its branch:

if (found = 0) { /* never taken - and found is now 0 */ }

Three defenses, in order of usefulness:

Compile with warnings. -Wall catches it:

warning: suggest parentheses around assignment used as truth value

Getting to zero warnings is the real fix here, and it costs one flag.

Write the constant first. The "Yoda condition" makes the typo a compile error:

if (5 == x)   /* correct */
if (5 = x)    /* error: not an lvalue - the compiler stops you */

Some teams love this and some find it unreadable; either position is defensible, but it does work.

Be deliberate when you mean it. Assignment inside a condition is genuinely useful for reading input:

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

The extra parentheses around c = getchar() are required for precedence, and they also signal that the assignment is intentional. That is the idiom - if your assignment-in-a-condition does not look like that, it is probably a typo.

Common Boolean Mistakes

Comparing to true. if (flag == true) works with stdbool.h, but it breaks the moment flag is an int holding 42, because 42 == 1 is false. Write if (flag).

Chained comparisons. if (0 < x < 10) is always true: 0 < x yields 0 or 1, and both are less than 10. Write if (x > 0 && x < 10).

Bitwise instead of logical. & and | are not && and ||. They do not short-circuit, and they combine bits:

#include <stdio.h>

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

    printf("a && b = %d\n", a && b);   /* 1 - both are non-zero */
    printf("a &  b = %d\n", a & b);    /* 0 - 01 AND 10 has no bits in common */
    return 0;
}

Both operands are "true," and yet a & b is 0. Using & where you meant && produces a condition that is wrong only for certain values, which is the hardest kind of bug to find.

Comparing floats for equality. if (0.1 + 0.2 == 0.3) is false. Compare against a tolerance instead - see data types for why.