In real-life, it’s common to ask or be asked questions that can be answered with “yes” or “no”. “Is an apple a fruit?” Yes. “Do you like asparagus?” No.
Now consider a similar statement that can be answered with a “true” or “false”: “Apples are a fruit”. It’s clearly true. Or how about, “I like asparagus”. Absolutely false (yuck!).
These kinds of sentences that have only two possible outcomes: yes/true, or no/false are so common, that many programming languages include a special type for dealing with them. That type is called a Boolean type (note: Boolean is properly capitalized in the English language because it’s named after its inventor, George Boole).
Boolean variables
Boolean variables are variables that can have only two possible values: true, and false.
To declare a Boolean variable, we use the keyword bool.
|
1 |
bool b; |
To initialize or assign a true or false value to a Boolean variable, we use the keywords true and false.
|
1 2 3 4 |
bool b1 { true }; bool b2 { false }; b1 = false; bool b3 {}; // default initialize to false |
Just as the unary minus operator (-) can be used to make an integer negative, the logical NOT operator (!) can be used to flip a Boolean value from true to false, or false to true:
|
1 2 |
bool b1 { !true }; // b1 will be initialized with the value false bool b2 { !false }; // b2 will be initialized with the value true |
Boolean values are not actually stored in Boolean variables as the words “true” or “false”. Instead, they are stored as integers: true becomes the integer 1, and false becomes the integer 0. Similarly, when Boolean values are evaluated, they don’t actually evaluate to “true” or “false”. They evaluate to the integers 0 (false) or 1 (true). Because Booleans actually store integers, they are considered an integral type.
Printing Boolean variables
When we print Boolean values with std::cout, std::cout prints 0 for false, and 1 for true:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
#include <iostream> int main() { std::cout << true << '\n'; // true evaluates to 1 std::cout << !true << '\n'; // !true evaluates to 0 bool b{false}; std::cout << b << '\n'; // b is false, which evaluates to 0 std::cout << !b << '\n'; // !b is true, which evaluates to 1 return 0; } |
Outputs:
1 0 0 1
If you want std::cout to print “true” or “false” instead of 0 or 1, you can use std::boolalpha. Here’s an example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
#include <iostream> int main() { std::cout << true << '\n'; std::cout << false << '\n'; std::cout << std::boolalpha; // print bools as true or false std::cout << true << '\n'; std::cout << false << '\n'; return 0; } |
This prints:
1 0 true false
You can use std::noboolalpha to turn it back off.
Integer to Boolean conversion
You can’t initialize a Boolean with an integer using uniform initialization:
|
1 2 3 4 5 6 7 8 9 |
#include <iostream> int main() { bool b{ 4 }; // error: narrowing conversions disallowed std::cout << b; return 0; } |
(note: some versions of g++ don’t enforce this properly)
However, in any context where an integer can be converted to a Boolean , the integer 0 is converted to false, and any other integer is converted to true.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
#include <iostream> int main() { std::cout << std::boolalpha; // print bools as true or false bool b1 = 4 ; // copy initialization allows implicit conversion from int to bool std::cout << b1 << '\n'; bool b2 = 0 ; // copy initialization allows implicit conversion from int to bool std::cout << b2 << '\n'; return 0; } |
This prints:
true false
Inputting Boolean values
Inputting Boolean values using std::cin sometimes trips new programmers up.
Consider the following program:
|
1 2 3 4 5 6 7 8 9 |
int main() { bool b {}; // default initialize to false (0) std::cout << "Enter a boolean value: "; std::cin >> b; std::cout << "You entered: " << b; return 0; } |
Enter a Boolean value: true You entered: 0
Wait, what?
It turns out that std::cin only accepts two inputs for Boolean variables: 0 and 1 (not true or false). Any other inputs will cause std::cin to silently fail. In this case, because we entered true, std::cin silently failed. In C++11 or newer, a failed input will also zero-out the variable, so b also gets assigned value 0. Consequently, when std::cout prints a value for b, it prints 0.
Boolean return values
Boolean values are often used as the return values for functions that check whether something is true or not. Such functions are typically named starting with the word is (e.g. isEqual) or has (e.g. hasCommonDivisor).
Consider the following example, which is quite similar to the above:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
#include <iostream> // returns true if x and y are equal, false otherwise bool isEqual(int x, int y) { return (x == y); // operator== returns true if x equals y, and false otherwise } int main() { std::cout << "Enter an integer: "; int x{ 0 }; std::cin >> x; std::cout << "Enter another integer: "; int y{ 0 }; std::cin >> y; std::cout << std::boolalpha; // print bools as true or false std::cout << x << " and " << y << " are equal? "; std::cout << isEqual(x, y); // will return true or false return 0; } |
Here’s output from two runs of this program:
Enter an integer: 5 Enter another integer: 5 5 and 5 are equal? true
Enter an integer: 6 Enter another integer: 4 6 and 4 are equal? false
How does this work? First we read in integer values for x and y. Next, the expression “isEqual(x, y)” is evaluated. In the first run, this results in a function call to isEqual(5, 5). Inside that function, 5 == 5 is evaluated, producing the value true. The value true is returned back to the caller to be printed by std::cout. In the second run, the call to isEqual(6, 4) returns the value false.
Boolean values take a little bit of getting used to, but once you get your mind wrapped around them, they’re quite refreshing in their simplicity! Boolean values are also a huge part of the language -- you’ll end up using them more than all the other fundamental types put together!
We’ll continue our exploration of Boolean values in the next lesson.
 4.10 -- Introduction to if statements |
 Index |
 4.8 -- Floating point numbers |
brace initialization shouldn't be allowed on line 5, in fact when I tried it wouldn't compile, complaining about "narrowing conversion of '4' from 'int' to 'bool'". so I changed it to copy initialization, but left the brace initialization on line 8 and it did compile, why is that?
Brace initialization doesn't allow conversions which can cause loss of data. If you convert 4 to a bool, you lost information, because afterwards you only know if the integer was 0 or not.
Hi.In "printing Boolean variables" section, shouldn't it be \n in the code instead of std::endl ?
It should, lesson updated. Thanks for pointing it out!
You're welcome.
Asparagus are great, come on! Fried (not deep fried) with salt and olive oil... :p Bacon is great with aspargus, by the way.
When you wrote:
"It turns out that std::cin only accepts two inputs for Boolean variables: 0 and 1 (not true or false). Any other inputs will cause std::cin to silently fail. In this case, because we entered true, std::cin silently failed. In C++11 or newer, this also sets b to 0 (which is the same value it had already been initialized with)."
Did you mean that when a user inputs a value other than 0 and 1 for Boolean variables using std::cin, the variable would be unaffected and would retain the value it had been initialized with?
Because I found that this program does not behave accordingly:
When the user inputs "false" or "true", the program always prints "Boolean value: 0", inconsistent with the initial value of the variable b (true).
Edit: My current guess is that I misunderstood you, in which you meant that such input would result in the variable b getting the value of 0 instead of retaining its initial value.
In C++11, failed inputs via std::cin operator >> cause the variable to be zero'd.
This program on running shows 0.1 with no precision. Explain?
`std::setprecision` doesn't do anything on its own. It returns an object that can be passed to a stream to modify the stream's precision.
Oook! Thanks.