C++ Booleans - True and False values

We've previously seen how we can create booleans - true or false values - within our code.

1bool isAlive { true };
2bool isDead { false };
3

Booleans are a fundamental data type - they're the standard way we control the flow of our program. Control flow is how we have our program do different things, reacting to user input and the state of our objects.

We'll see more of how we can use booleans to control our programs starting in the Conditional Logic lesson. For now, lets see some of the most common ways we can create and manipulate them.

Creating Booleans by Comparing Numbers

One of the main ways we create booleans is by using specific operators on other data types, particularly numbers.

Two sequential equals characters, the == operator, allows us to compare two numbers. When placed between the numbers, it will return the boolean value true if they equal, and false otherwise.

1int Level { 10 };
2
3// Level is 10, so isLevel10 will be true
4bool isLevel10 { Level == 10 };
5
6// This will be false
7bool isLevel15 { Level == 15 };
8

We can also compare two integer variables:

1int Level { 20 };
2int TargetLevel { 20 };
3
4// This will be true
5bool isTargetLevel { Level == TargetLevel};
6

We also have the != operator, which will do the exact opposite. It will evaluate to true if the two numbers are not equal, otherwise it will return false.

1int Level { 10 };
2bool isNotLevel10 { Level != 10 }; // false
3bool isNotLevel15 { Level != 15 }; // true
4

We have 4 other useful operators we can use with numbers:

• The greater than operator: >
• The greater than or equal to operator: >=
• The less than operator: <
• The less than or equal to operator: <=

Lets look at some examples:

1int Level { 10 };
2
3bool isAboveLevel10 { Level > 10 }; // False
4bool isAtLeastLevel10 { Level >= 10 }; // True
5
6bool isBelowLevel10 { Level < 10 }; // False
7bool isLevel10OrBelow { Level <= 10 }; // True
8

Floating point numbers have these operators too, and we can compare float and int values freely.

1float Health { 100.0 };
2bool isHealthy { Health > 50.0 };
3bool isMaxHealth { Health >= 100 };
4

We can also combine maths with the boolean operators:

1float MaxHealth { 150.0 };
2bool isAbove50Percent { Health / MaxHealth > 0.5 };
3

1bool MyBoolean { 15 > 15 };
2

1bool MyBoolean { 15 >= 10 + 5 };
2

Inverting C++ Booleans with !

We can invert booleans (ie, converting true to false, or false to true) using the ! operator, for example:

1bool isAlive { true };
2bool isDead { !isAlive };
3

Combining C++ Booleans

We can combine two or more booleans in order to evaluate more than one thing at once. If we use two ampersands - the && operator, we can check if multiple things are true.

1int Level = 10;
2bool isAlive = true;
3
4// This will be true
5bool isReady { Level == 10 && isAlive };
6

We can also use the or operator denoted by || to evaluate if at least one thing is true, in a set of checks. For example:

1int Level = 10;
2
3// This will be true
4bool isReady { Level == 10 || Level == 20 };
5

We're not restricted to just combining two booleans. We can combine as many booleans as we want using these operators.

The following sample is using multiple lines of code to initialise a single value. We can add additional space to our code as needed to make things clearer. We talk more about white space in the following section:

1int Level = 10;
2bool isDead { true };
3
4// This will be true
5bool isMilestoneLevel {
6  Level == 10 || Level == 20 || Level == 30
7};
8
9// This will be false
10bool canStartQuest {
11  Level >= 10 && Level <= 20 && !isDead
12};
13

We can use both || and && operators in the same statement. Typically, when doing this, we will also need to introduce brackets ( and ) in order to specify how our checks get grouped together.

1int Level { 10 };
2bool isAlive { true };
3
4bool isLevel10Or20AndAlive {
5  (Level == 10 || Level == 20) && isAlive
6};
7

C++ Doesn't Care about White Space

You may have noticed by now that how you space out your code is not of much importance to the compiler. Spaces, tabs and line breaks are commonly called white space and you can add or remove them as you wish.

The positioning of syntax like } and ; is what matters from the compiler's perspective. Line breaks and block of space are to help us humans make the most sense of the code, so you can choose what works best for you.

Lets see some examples:

1// We can have multiple statements on one line
2int Level { 10 }; int MaxLevel { 50 };
3
4// We can have one statement across multiple lines
5bool isAlive {
6true
7};
8
9// When we do this, indenting can make things clearer
10bool isImmortal {
11  false
12};
13
14// Spacing a complicated statement across multiple
15// lines can make it a bit easier to follow
16bool isReady {
17  Level == MaxLevel &&
18  (isAlive || isImmortal) &&
19  Health / MaxHealth > 0.5f
20};
21

1bool isCorrectLevel { Level < 10 && Level > 20 };
2

1int Health = 0;
2bool isImmortal = false;
3bool isDead { Health == 0 && !isImmortal };
4

Common Mistakes when working with C++ Booleans

There are two common mistakes beginners make when working with booleans. The first is forgetting to repeat the variable name when combining booleans, eg:

1int Level { 15 };
2
3// This will be true, but we might expect it to be false
4bool isReady { Level == 10 || 20 };
5

Line 3 makes sense in plain language - "is Level equal to 10 or 20?" - but it's a little too ambiguous for code.

It gets interpreted as (Level == 10) || (20)

Because 20 is considered true, the overall boolean simplifies to false || true, which further simplifies to true.

To fix the above mistake, we need to specify the variable we're comparing against each time, as shown below.

1int Level { 15 };
2
3// This will now be false
4bool isReady { Level == 10 || Level == 20 };
5

The second most common mistake comes from not using brackets when combining the || or && operator, in a statement like this:

1int Level { 10 };
2bool isAlive { false };
3
4// This will be true, because Level == 10
5bool isReady {
6  Level == 10 || Level == 20 && isAlive
7};
8

When booleans combine || and &&, the && operators are evaluated first. As a result, line 5 gets interpreted as the following:

1Level == 10 || (Level == 20 && isAlive)
2

Therefore, if Level == 10 the combined boolean will be true regardless of the value of isAlive. The code below adds ( and ) in the correct places, to clarify our intent.

1int Level { 10 };
2bool isAlive { false };
3
4// This will be false, because isAlive is false
5bool isReady {
6  (Level == 10 || Level == 20) && isAlive
7};
8

Lets combine our knowledge of numbers and booleans, and learn how to use the debugger so we can see what is happening inside our programs.