How to Use Boolean Values in C

By the end of this page, you will understand how Boolean values are represented in C, the difference between older and modern approaches, how to use _Bool and stdbool.h, and how to write clear, idiomatic C code when working with true/false conditions.

In C, Boolean logic has existed from the beginning, but for a long time the language did not provide a friendly Boolean type name like bool. Instead, C used integer values in conditions:

• 0 means false
• any non-zero value means true

That means code like this has always worked:

if (5) {
    printf("true\n");
}

However, modern C provides a real Boolean type through:

• the built-in type _Bool
• the header stdbool.h, which defines bool, true, and false

Example:

#include <stdbool.h>

bool is_ready = true;

This is the recommended approach in modern C because it makes code easier to read and communicates intent clearly.

Why this matters

Using a proper Boolean type improves:

• readability: bool is_admin is clearer than int is_admin
• maintainability: future developers immediately understand the variable's purpose
• correctness of intent: the code expresses logical state, not arbitrary numbers

Important detail about _Bool

_Bool stores Boolean values as either 0 or 1.

If you assign any non-zero number to a _Bool, it becomes 1.

_Bool a = 0;   // false
_Bool b = 7;   // becomes 1

This makes _Bool useful when you want true/false behavior rather than general numeric storage.

Think of a Boolean as a light switch:

• false = off
• true = on

In older C code, programmers often used an int as the switch:

• 0 = off
• any other number = on

That works, but it is like using a whole dimmer panel just to represent simple on/off state.

Using bool is like installing a real switch labeled ON/OFF. It makes the purpose obvious and avoids confusion.

Modern C syntax

Use stdbool.h when available:

#include <stdbool.h>

int main(void) {
    bool is_logged_in = true;
    bool has_permission = false;

    if (is_logged_in) {
        printf("User is logged in\n");
    }

    if (!has_permission) {
        printf("Access denied\n");
    }

    return 0;
}

What this does

• bool is the Boolean type
• true and false are readable Boolean constants
• !has_permission means "not has_permission"

Using _Bool directly

#include <stdio.h>

int main(void) {
    _Bool ok = 1;
    _Bool failed = 0;

    printf("ok = %d\n", ok);
    printf("failed = %d\n", failed);

    return 0;
}

This works, but bool is usually easier to read.

Older style using int

Before stdbool.h, many programs used int:

#include <stdio.h>

#define TRUE 1
#define FALSE 0

int main(void) {
    int done = FALSE;

    done = TRUE;

    if (done) {
        printf("Done\n");
    }

    return 0;
}

This still works, especially in older codebases, but modern code should prefer bool when possible.

Assignment behavior

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

int main(void) {
    bool a = 0;
    bool b = 42;

    printf("a = %d\n", a);
    printf("b = %d\n", b);

    return 0;
}

Output:

a = 0
b = 1

Even though 42 was assigned, bool stores it as 1.

Consider this program:

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

int main(void) {
    bool has_items = 3;

    if (has_items) {
        printf("Cart is not empty\n");
    } else {
        printf("Cart is empty\n");
    }

    return 0;
}

Step by step

1. #include <stdbool.h> makes bool, true, and false available.
2. bool has_items = 3; assigns 3 to a Boolean.
3. Because has_items is a Boolean type, the stored value becomes 1.
4. The if (has_items) condition checks whether the value is true.
5. Since has_items is 1, the condition is true.
6. The program prints:

Cart is not empty

Key idea

When using bool or _Bool:

• 0 stays false
• any non-zero value becomes true, stored as 1

Boolean values are used everywhere in real programs.

Common use cases

• Feature flags

  • bool dark_mode_enabled
  • bool logging_enabled

• Validation results

  • bool is_valid_email
  • bool input_ok

• State tracking

  • bool is_connected
  • bool file_open
  • bool is_finished

• Permission checks

  • bool is_admin
  • bool can_delete

• Function return values

  • a function can return true for success and false for failure in simple cases

Example:

#include <stdbool.h>

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

This is common in utility functions and validation logic.

In real C codebases, developers usually use Boolean values in a few common patterns.

Guard clauses

Return early when a condition is not met:

#include <stdbool.h>

bool process_order(int order_id) {
    if (order_id <= 0) {
        return false;
    }

    return true;
}

Validation helpers

Small helper functions often return bool:

#include <stdbool.h>
#include <ctype.h>

bool is_digit_char(char c) {
    return c >= '0' && c <= '9';
}

Configuration flags

Applications often store options as Booleans:

typedef struct {
    bool verbose;
    bool dry_run;
} Config;

Error handling

Some functions return bool to indicate success, while output data is written through pointers:

#include <stdbool.h>

bool divide(int a, int b, int *result) {
    if (b == 0) {
        return false;
    }

    *result = a / b;
    return true;
}

This pattern is very common in C APIs.

Clear naming

Real projects often name Boolean variables with prefixes like:

• is_
• has_
• can_
• should_

Examples:

• is_ready
• has_error
• can_retry
• should_log

These names make conditions read like plain language.

1. Using int when bool would be clearer

This works:

int is_valid = 1;

But this is clearer:

bool is_valid = true;

Use bool when the value is truly just yes/no.

2. Forgetting to include stdbool.h

Broken code:

bool ready = true;

If stdbool.h is not included, bool, true, and false may be unknown.

Correct version:

#include <stdbool.h>

bool ready = true;

3. Comparing Boolean values unnecessarily

Less clear:

if (is_ready == true) {

Better:

if (is_ready) {

And instead of:

if (is_ready == false) {

Use:

if (!is_ready) {

4. Assuming only 1 is true in normal integer conditions

In C conditions, any non-zero value is true.

if (5) {
    printf("true\n");
}

That is valid.

5. Mixing Boolean meaning with numeric meaning

Broken design:

int status = 2;
if (status) {
    printf("Success? Maybe?\n");
}

Here status may represent multiple states, not just true/false. A bool would be wrong if more than two states are needed.

Use:

• bool for yes/no
• enum or int for multiple statuses

6. Printing Booleans as words without handling formatting

printf does not have a special Boolean format specifier.

printf("%d\n", flag);

This prints 0 or 1.

If you want words:

printf("%s\n", flag ? "true" : "false");

Boolean options in C

bool vs int

When to use each

• Use bool for flags and yes/no states.
• Use int for counts, arithmetic, and numeric status codes.
• Use enum when there are more than two possible states.

Quick reference

Recommended modern approach

#include <stdbool.h>

bool flag = true;
flag = false;

Built-in Boolean type

_Bool flag = 1;

Boolean rules in C

• 0 means false
• non-zero means true in conditions
• assigning non-zero to _Bool or bool stores 1

Typical condition style

if (flag) {
    /* true */
}

if (!flag) {
    /* false */
}

Return a Boolean from a function

#include <stdbool.h>

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

Print a Boolean

printf("%d\n", flag);
printf("%s\n", flag ? "true" : "false");

Best practice

• Prefer bool over int for logical values
• Include stdbool.h
• Use clear names like is_open, has_error, can_save
• Do not use bool for values with more than two states

Does C have a Boolean type?

Yes, modern C has the built-in type _Bool, and stdbool.h provides the friendlier alias bool plus true and false.

Should I use bool or int in C?

Use bool for values that are only true/false. Use int when the variable stores numeric data.

What header do I need for bool in C?

Include:

#include <stdbool.h>

Is true always equal to 1 in C?

With bool and _Bool, true is stored as 1. In general C conditions, any non-zero value is treated as true.

Can I use TRUE and FALSE macros?

You can, especially in older code, but modern C usually prefers bool, true, and false from stdbool.h.

Why does if (5) count as true in C?

Because C treats any non-zero value in a condition as true.

Can a function return bool in C?

Yes. This is common for validation, success/failure checks, and helper functions.

What should I use if there are more than two states?

Use an enum or another numeric type instead of bool.

Related concepts

• if statements — Boolean values are most often used in conditions.
• Comparison operators — expressions like ==, !=, <, and > produce true/false results.
• Logical operators — &&, ||, and ! combine or invert Boolean expressions.
• _Bool — the built-in Boolean type behind bool in C.
• stdbool.h — the standard header that provides bool, true, and false.
• enum — useful when a variable can be in more than two states.
• Guard clauses — often use Boolean conditions for early returns.
• Function return values — many C functions return Boolean success/failure results.