bool in C++: true, false and how to use them

A bool in C++ is a built-in type with two values, true and false. Declare a bool variable with bool done = false; and use it wherever a condition goes: if (done). Comparisons such as age >= 18 produce a bool, and std::cout prints one as 1 or 0 unless you send std::boolalpha first.

A ticket check, as a whole program:

#include <iostream>

int main() {
    int age = 20;
    bool is_adult = age >= 18;  // a comparison gives a bool

    if (is_adult) {
        std::cout << "Adult ticket\n";
    } else {
        std::cout << "Child ticket\n";
    }
    std::cout << "is_adult = " << is_adult << '\n';  // prints 1
}

It printed:

Adult ticket
is_adult = 1

age >= 18 asks a question, and its answer, true for an age of 20, is stored in is_adult.

The samples are C++17, built with MSVC 19.44, Clang 19.1 (MSVC STL), GCC 16.2 and Clang 23.1 (libc++), and all four printed the same. bool, true and false go back to the first standard, C++98 (Since When lists the compiler releases for each standard from C++11 on).

What produces a bool in C++?

Comparisons produce one: == (equal), != (not equal), <, >, <= and >=. The logical operators combine bools into a new one: && (and), || (or) and ! (not) (logical operators on cppreference). On the ticket check:

int age = 20;
bool has_ticket = false;

std::cout << std::boolalpha;
std::cout << (age == 20) << '\n';                // true
std::cout << (age < 18) << '\n';                 // false
std::cout << (age >= 18 && has_ticket) << '\n';  // false
std::cout << (age >= 18 || has_ticket) << '\n';  // true
std::cout << !has_ticket << '\n';                // true

// the same operators spelled as words
std::cout << (age >= 18 and not has_ticket) << '\n';  // true
std::cout << (age < 18 or has_ticket) << '\n';        // false

Each line printed the word in its comment. and, or and not are the same operators spelled as words, part of the language, with no header to include; MSVC accepts them only in its standard-conforming mode, /permissive-, which /std:c++20 and later turn on (Microsoft Learn on &&). For two bools a and b:

!a is true when a is false, and false when it is true.

Do && and || always run both sides?

No. && stops when its left side is false, and || stops when its left side is true, because the answer is already known; the right side then never runs. This is called short-circuit evaluation:

bool check_ticket() {
    std::cout << "check_ticket() called\n";
    return true;
}
// ...
bool is_adult = false;
bool is_staff = true;

if (is_adult && check_ticket()) {  // is_adult is false: no call
    std::cout << "adult with a ticket\n";
}
if (is_staff || check_ticket()) {  // is_staff is true: no call
    std::cout << "let in\n";
}

if (is_staff && check_ticket()) {  // is_staff is true: called
    std::cout << "staff with a ticket\n";
}

It printed:

let in
check_ticket() called
staff with a ticket

The first two ifs never called check_ticket(); the third did, because a true on the left of && leaves the answer open. So a function on the right of && or || may not run at all: do not count on what it does, such as the line it prints.

Why does cout print a bool as 1 or 0?

Because digits are the default: a stream prints true as 1 and false as 0 until you send it std::boolalpha, which switches it to the words (std::boolalpha on cppreference).

bool is_adult = true;
bool has_ticket = false;

std::cout << is_adult << ' ' << has_ticket << '\n';  // 1 0
std::cout << std::boolalpha;  // from here on: words
std::cout << is_adult << ' ' << has_ticket << '\n';  // true false

std::cout << std::noboolalpha;  // back to numbers
std::cout << is_adult << '\n';  // 1

It printed:

1 0
true false
1

The setting stays on std::cout for every bool printed after it, until std::noboolalpha turns it off; how to print with std::cout covers the stream’s other settings, such as decimals. Sent to std::cin, it does the same for input: the stream reads the words true and false instead of 1 and 0. To print the word once without changing the stream, pick it with the ternary operator, parentheses included: std::cout << (is_adult ? "true" : "false"); (without them << runs first and the line prints 1).

What converts to bool, and what does a bool turn into?

A number converts to false when it is 0 and to true when it is anything else, negative numbers included, and a null pointer converts to false (implicit conversions on cppreference). The other way, true becomes 1 and false becomes 0:

int zero = 0;
int five = 5;
int minus_one = -1;
double nothing = 0.0;
int* seat = nullptr;

bool a = zero;       // false
bool b = five;       // true
bool c = minus_one;  // true: any number but 0
bool d = nothing;    // false
bool e = seat;       // false: a null pointer

std::cout << std::boolalpha;
std::cout << a << ' ' << b << ' ' << c << ' '
          << d << ' ' << e << '\n';

int one = true;    // 1
int none = false;  // 0
std::cout << one << ' ' << none << '\n';
std::cout << true + true << '\n';  // 2: an int, not a bool

It printed:

false true true false false
1 0
2

true + true is not true: both sides become the int 1 before the addition, so the result is the int 2, printed as 2 even with std::boolalpha set. The same rule decides a condition, so if (seat) takes its branch only when the pointer is not null.

How do you write a bool function in C++?

Give it the return type bool and return the condition itself. Name it as a yes-or-no question, such as is_even, so that the call reads as one inside an if:

bool is_even(int n) {
    return n % 2 == 0;
}
// ...
int tickets = 4;
if (is_even(tickets)) {
    std::cout << tickets << " tickets: an even number\n";
}
if (!is_even(7)) {
    std::cout << "7 is odd\n";
}

It printed 4 tickets: an even number and 7 is odd. n % 2 is the remainder after dividing by 2, so n % 2 == 0 is already the answer: a bool function returns it, with no if that returns true in one branch and false in the other. ! turns the question around: !is_even(7) is true.

Is it bool or boolean in C++?

It is bool. C++ has no type named boolean, and bool is a keyword, so it needs no header (fundamental types on cppreference). Writing boolean is an error:

boolean ready = true;  // error: C++ has no type named boolean

All four compilers rejected it; GCC said:

error: 'boolean' was not declared in this scope; did you mean 'bool'?

Common bool mistakes

Each with its fix:

• if (done = true) assigns instead of comparing: = stores true in done, so the test is always true, and the branch was taken. All four compilers warned (MSVC C4706, “assignment used as a condition”, at /W4; GCC and Clang under -Wparentheses, with -Wall -Wextra). Write if (done).
• if (is_adult == true) compares a value that is already a bool; if (is_adult) says the same thing.
• A local bool ok; with no value is not set to anything and must not be read. Write bool ok{}; (empty braces give false) or bool ok = false;.
• A single & is the bitwise and: it always runs both sides, and on numbers it combines bits, so with 2 and 1 tickets & seats is 0 while tickets && seats is true. Between two conditions write &&.
• std::vector<bool> is a special case: it may pack its values into less space, and v[i] returns a stand-in object (a proxy), not a reference to a bool, so it does not behave like other vectors (std::vector of bool on cppreference).

The Language section has the other answers on the core language.