Booleans - true and false values

In this lesson, we introduce the concept of booleans in C++. Booleans are one of the simplest yet most powerful data types in programming. They represent the concept of binary states — true or false. You can think of them as the answer to a yes-or-no question.

Understanding Booleans is crucial because they form the backbone of decision-making in code. They help us answer questions like: "Is this condition met?" or "Should this action be performed?"

They are the key to controlling how a program behaves and responds to different scenarios. We've already seen a glimpse of how we can create booleans:

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

In this lesson, we'll explore more on how to create, manipulate, and use these fundamental types to direct the flow of our programs. We'll start with the basics of creating booleans through comparisons and then move on to more complex operations.

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 };

We can also compare two integer variables:

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

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

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: <=

Let's 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

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 };

We can also combine maths with the boolean operators, creating more complex expressions:

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

1bool MyBoolean { 15 > 15 };

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

1#include <iostream>
2using namespace std;
3
4int main() {
5  int Health{100};
6
7  Health -= 50;
8  if (Health <= 0) { // false 
9    cout << "I have been defeated";  
10  }                                  
11
12  Health -= 50;
13  if (Health <= 0) { // true 
14    cout << "I have now been defeated";  
15  }                                  
16}

1I have now been defeated

Inverting Booleans with the ! Operator

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

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

Combining Booleans

We can combine two or more booleans to evaluate more complex situations. This can be done using two ampersands - the && operator.

It allows us to check if two things - the left and right operands - are both true. && is sometimes referred to as the "logical and" operator:

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

We can also use the "logical or" operator denoted by || to evaluate if either the left or right operand is true. For example:

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

We're not restricted to just combining two booleans. We can test as many conditions as we desire by using the operators multiple times in a single expression:

1// true only if ALL conditions are true
2Condition1 && Condition2 && Condition3;
3
4// true if ANY condition is true
5Condition1 || Condition2 || Condition3;

The following example uses multiple lines of code to initialize a single value. We can add additional space to our code as needed to make things clearer:

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

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

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

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};

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

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

Common Mistakes

There are a few common mistakes that are made when working with booleans.

Mistake 1 - Not repeating the variable name in compound booleans

The first mistake is believing we don’t need to repeat the variable name when combining multiple booleans. Variations of this error typically look something like this:

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

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 };

Mistake 2 - Not controlling the order of operations

Another 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};

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

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

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};

Mistake 3 - Using & and | instead of && and ||

The final mistake worth highlighting is that beginners make is not using the correct operators. The boolean operators we usually want use two keystrokes - && and ||

The problem is that & and | are also valid operators - commonly called bitwise operators - which we cover in detail later. Bitwise operators are used less frequently than their logical counterparts. However, because they are valid operators, our tools often won’t realize we’ve made a mistake - instead we will just have a bug.

1bool A{1 & 2}; // false
2bool B{1 && 2}; // true

If our code is compiling and running successfully, but our boolean does not have the value we expect, it’s worth double-checking to ensure we’re using the correct operators.

Summary

In this lesson, we've covered several key aspects of using Booleans. Here's a quick recap of what we've learned:

• Basics of Booleans: Introduced to Booleans as true or false values.
• Creating Booleans: Learned how to create Booleans by comparing numbers using operators like ==, !=, >, <, >=, and <=.
• Inverting Booleans: Discovered the use of the ! operator to invert Boolean values.
• Combining Booleans: Learned to combine Booleans using && (logical AND) and || (logical OR) operators.
• Boolean Order of Operations: Practiced creating complex Boolean expressions and controlling their evaluation order with parentheses.
• Common Mistakes: Identified and corrected common mistakes like improper use of operators and incorrect grouping of conditions.

Next Lesson

Types and Literals

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

ContinueView Course