Booleans - true and false values

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

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 };
2
3// True
4bool isHealthy { Health > 50.0 };
5
6// True
7bool isMaxHealth { Health >= 100 };

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

1float Health { 100.0 };
2float MaxHealth { 150.0 };
3
4// True
5bool isAbove50Percent { Health / MaxHealth > 0.5 };

1bool MyBoolean { 15 > 15 };

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

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

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

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
4// This will be true
5bool isLevel10Or20AndAlive {
6  (Level == 10 || Level == 20) && isAlive
7};

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

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

There are a few common mistakes that are made when working with 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 4 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 };

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

The final mistake worth highlighting is not using the correct operators. The boolean operators we usually want use two characters - && 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.

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.