Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

Booleans - `true` and `false` values

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

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

This is a great question! Even though a boolean only needs a single bit (0 or 1) to store its value, in C++ and most other programming languages, booleans typically use a whole byte of memory. Let's explore why this design decision was made.


## Memory Access Efficiency


Modern computers are designed to access memory in chunks of bytes (8 bits), not individual bits. Trying to access individual bits would actually be slower than accessing whole bytes, because the computer would need to do extra work to figure out which bit to read or write.


Think of it like a library where books can only be accessed by shelf, not individually. Even if you only want one page from a book, you need to take the whole book off the shelf.


Here's a simple program that shows us the size of a boolean:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  cout << "Size of bool: "
    << sizeof(isAlive) << " byte\n";

  // We can have an array of booleans
  bool flags[8]{true, false, true,
    true, false, false, true, false};
  cout << "Size of 8 bools: "
    << sizeof(flags) << " bytes";
}
```


```c++
//<o>
Size of bool: 1 byte
Size of 8 bools: 8 bytes
```


## Memory Alignment


Another reason for using a whole byte is memory alignment. Modern computers work most efficiently when data is aligned on certain boundaries. Using full bytes helps maintain this alignment without requiring special handling.


## Space vs Speed Tradeoff


While it might seem wasteful to use 8 bits when we only need 1, the performance benefits of byte-aligned access usually outweigh the memory cost. In most programs, the extra memory used by booleans is negligible compared to other data types like integers (4 bytes) and floating-point numbers (4 or 8 bytes).


If you do need to store many boolean values efficiently, C++ provides special container types like `std::vector<bool>` which we'll learn about later that can pack multiple boolean values into single bytes.

Why Booleans Take a Byte of Memory

When working with floating-point numbers, direct comparisons using `==` can be problematic because of how computers represent decimal numbers. Let's look at why this happens and how to handle it properly.


## The Problem


Here's an example that demonstrates why floating-point comparisons can be tricky:


```c++
#include <iostream>
using namespace std;

int main() {
  float x{0.1f + 0.2f};
  float y{0.3f};

  // This might print "false" even though
  // mathematically they're equal!
  cout << "Direct comparison (x == y): "
    << (x == y) << "\n";
  cout << "Value of x: " << x << "\n";
  cout << "Value of y: " << y;
}
```


```c++
//<o>
Direct comparison (x == y): false
Value of x: 0.3
Value of y: 0.3
```


Even though both numbers print as 0.3, they might not be exactly equal internally due to how floating-point numbers are stored in memory.


## The Solution: Compare with Tolerance


Instead of checking for exact equality, we should check if the numbers are "close enough" by defining an acceptable difference (often called epsilon or tolerance):


```c++
#include <iostream>
using namespace std;

int main() {
  float Health{100.0f};
  float MaxHealth{100.0f};
  float Damage{33.33f};

  // Apply damage
  Health = Health - Damage;

  // This is safer than using ==
  float Tolerance{0.0001f};
  bool areEqual{
    (Health - MaxHealth) < Tolerance &&
    (MaxHealth - Health) < Tolerance
  };

  cout << "Health: " << Health << "\n";
  cout << "Are equal?: " << areEqual << "\n";

  // For less/greater comparisons
  // we can still use < and >
  bool isHealthy{Health > 50.0f};
  cout << "Is healthy?: " << isHealthy;
}
```


```c++
//<o>
Health: 66.67
Are equal?: false
Is healthy?: true
```


Note that `<` and `>` comparisons are generally safe with floating-point numbers. It's primarily the equality comparison that needs special handling.


The actual value you use for `Tolerance` depends on your specific needs - smaller values mean more precise comparisons but are more likely to fail due to floating-point imprecision.

Safe Floating-Point Comparisons

When working with multiple boolean conditions, there are several ways to make your code both faster and easier to understand. Let's explore some key techniques.


## Order Your Conditions Wisely


In C++, boolean expressions are evaluated from left to right, and the evaluation stops as soon as the final result is known. This is called "short-circuit evaluation". We can use this to our advantage:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{false};
  bool isInCombat{true};
  bool hasMagic{true};

  // Bad order - checks everything even when
  // isAlive is false
  bool canFight{//<w>
    hasWeapon && isAlive && isInCombat}; //<w>

  // Better order - stops checking if
  // isAlive is false
  bool canFightOptimized{//<h>
    isAlive && hasWeapon && isInCombat}; //<h>

  cout << "Can fight: " << canFightOptimized;
}
```


```c++
//<o>
Can fight: false
```


Put your quickest and most likely-to-fail checks first when using `&&`, and put your quickest and most likely-to-succeed checks first when using `||`.


## Group Related Conditions


When you have many conditions, grouping related ones with parentheses makes your code easier to understand and maintain:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{true};
  bool hasMagic{true};
  bool hasAmmo{false};
  bool hasMana{true};

  // Hard to understand at a glance //<w>
  bool canAttack{
    isAlive && hasWeapon && hasAmmo
    || hasMagic && hasMana};

  // Clearer grouping makes the logic obvious //<h>
  bool canAttackClearer{
    isAlive && (
      (hasWeapon && hasAmmo) ||
      (hasMagic && hasMana)
    )};

  cout << "Can attack: " << canAttackClearer;
}
```


```c++
//<o>
Can attack: true
```


## Break Down Complex Conditions


If you have a very complex condition, breaking it into smaller named booleans can make your code more readable and maintainable:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{true};
  bool hasMagic{true};
  bool hasAmmo{false};
  bool hasMana{true};
  int Level{5};

  // Break down complex conditions into parts
  bool hasPhysicalAttack{hasWeapon && hasAmmo};
  bool hasMagicalAttack{hasMagic && hasMana};
  bool meetsLevelRequirement{Level >= 5};

  bool canAttack{
    isAlive && meetsLevelRequirement &&
    (hasPhysicalAttack || hasMagicalAttack)
  };

  cout << "Can attack: " << canAttack;
}
```


```c++
//<o>
Can attack: true
```


These techniques not only make your code faster and more efficient but also make it easier to read, understand, and modify later.

Optimizing Boolean Logic

When you need to remember previous boolean states, you can store the old value in a separate variable before updating the current state. This is especially useful for detecting changes or transitions in your program's state.


## Basic State Tracking


Here's a simple example of tracking a state change:


```c++
#include <iostream>
using namespace std;

int main() {
  bool wasAlive{true}; // Previous state
  bool isAlive{true}; // Current state
  int Health{100};

  // Store the previous state before updating
  wasAlive = isAlive;

  // Update current state based on health
  Health = Health - 150; // Take massive damage
  isAlive = Health > 0;

  // We can now check if the state just changed
  bool justDied{wasAlive && !isAlive};

  if (justDied) {
    cout << "Game Over - you just died!\n";
  } else if (!wasAlive && !isAlive) {
    cout << "Still dead\n";
  } else if (wasAlive && isAlive) {
    cout << "Still alive\n";
  }
}
```


```c++
//<o>
Game Over - you just died!
```


## Tracking Multiple State Changes


You can track multiple state changes by keeping multiple previous states:


```c++
#include <iostream>
using namespace std;

int main() {
  // Track battle status
  bool wasInCombat{false};
  bool isInCombat{false};
  bool hasWeapon{true};

  // First update
  wasInCombat = isInCombat;
  isInCombat = true;

  bool justEnteredCombat{
    !wasInCombat && isInCombat};
  if (justEnteredCombat) {
    cout << "Combat started!\n";
    if (!hasWeapon) {
      cout << "Warning: Entered combat without "
        "a weapon!\n";
    }
  }

  // Second update
  wasInCombat = isInCombat;
  isInCombat = false;

  bool justLeftCombat{
    wasInCombat && !isInCombat};
  if (justLeftCombat) {
    cout << "Combat ended!";
  }
}
```


```c++
//<o>
Combat started!
Combat ended!
```


By storing the previous state, we can detect important transitions in our program, like when a player enters or leaves combat, when they gain or lose an ability, or when they cross important thresholds.


This is particularly useful in games and interactive applications where you need to trigger specific actions when states change.

Tracking Boolean State Changes

There are two ways to check if a boolean is `false` in C++, and while they give the same result, one is generally preferred. Let's explore both approaches and understand why one is better.


## The Two Approaches


Here's a comparison of both methods:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{false};

  // Method 1: Using the ! operator
  if (!isAlive) {
    cout << "Not alive (using !)\n";
  }

  // Method 2: Comparing with == false //<w>
  if (isAlive == false) {
    cout << "Not alive (using == false)";
  }
}
```


```c++
//<o>
Not alive (using !)
Not alive (using == false)
```


## Why `!` is Preferred


The `!` operator is preferred for several reasons:

- It's shorter and cleaner to write
- It's faster to read and understand
- It's less prone to typing mistakes
- It's more idiomatic (experienced C++ programmers expect to see it)

Here's an example showing how `!` can make complex conditions more readable:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{false};
  bool isInCombat{true};

  // Using == false makes the code longer and
  // harder to read
  bool cannotFight{//<w>
    isAlive == false || hasWeapon == false//<w>
    || isInCombat == false};//<w>

  // Using ! is cleaner and more readable
  bool cannotFightBetter{//<h>
    !isAlive || !hasWeapon || !isInCombat}; //<h>

  cout << "Cannot fight: " << cannotFightBetter;
}
```


```c++
//<o>
Cannot fight: true
```


## Common Mistakes to Avoid


Be careful not to accidentally use assignment (`=`) instead of comparison (`==`):


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{false};

  // This is a common mistake - we're not
  // testing isAlive, we're updating it!
  if (isAlive = false) {//<w>
    cout << "This will not print because"
      " = assigns false to isAlive\n";
  }

  // Using ! avoids this potential error
  if (!isAlive) {//<h>
    cout << "This is clearer and safer";
  }
}
```


```c++
//<o>
This is clearer and safer
```


The `!` operator makes this kind of mistake impossible, which is another reason it's preferred.

Not Operator vs Equals False

When dealing with complex boolean expressions, there are several techniques that can help you understand what's happening and find problems. Let's explore some practical debugging approaches.


## Print Individual Conditions


Break down complex expressions and print each part:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{false};
  bool hasMagic{true};
  bool hasAmmo{true};
  bool hasMana{false};

  // Print individual conditions
  cout << "Status:\n";
  cout << "- isAlive: " << isAlive << "\n";
  cout << "- hasWeapon: " << hasWeapon << "\n";
  cout << "- hasMagic: " << hasMagic << "\n";

  // Check complex condition
  bool canAttack{isAlive && (
    (hasWeapon && hasAmmo) ||
    (hasMagic && hasMana)
  )};

  cout << "Can attack: " << canAttack;
}
```


```c++
Status:
- isAlive: 1
- hasWeapon: 0
- hasMagic: 1
Can attack: 0
```


## Break Down Complex Expressions


Split complex conditions into named parts that describe what they check:


```c++
#include <iostream>
using namespace std;

int main() {
  bool isAlive{true};
  bool hasWeapon{false};
  bool hasMagic{true};
  bool hasAmmo{true};
  bool hasMana{false};

  // Break down the logic into meaningful parts
  bool hasPhysicalAttack{hasWeapon && hasAmmo};
  bool hasMagicalAttack{hasMagic && hasMana};

  cout << "Combat Checks:\n";
  cout << "- Can use physical: "
    << hasPhysicalAttack << "\n";
  cout << "- Can use magic: "
    << hasMagicalAttack << "\n";

  bool hasAnyAttack{
    hasPhysicalAttack || hasMagicalAttack};
  cout << "- Has any attack: "
    << hasAnyAttack << "\n";

  bool canAttack{isAlive && hasAnyAttack};
  cout << "Final result - Can attack: "
    << canAttack;
}
```


```c++
//<o>
Combat Checks:
- Can use physical: 0
- Can use magic: 0
- Has any attack: 0
Final result - Can attack: 0
```


## Add Temporary Debug Comments


When debugging, you can add comments showing the expected values:


```c++
#include <iostream>
using namespace std;

int main() {
  int Health{75};
  int MaxHealth{100};
  bool hasShield{true};

  // Add comments showing expected values
  // 75 > 50: should be true
  bool isHealthy{ Health > MaxHealth / 2 };

  // Should be true
  bool canTakeDamage{
      isHealthy ||  // true
      hasShield     // true
  };                

  cout << "Health: " << Health << "/"
    << MaxHealth << "\n";
  cout << "Has shield: " << hasShield << "\n";
  cout << "Is healthy: " << isHealthy << "\n";
  cout << "Can take damage: "
    << canTakeDamage << "\n";
}
```


```c++
//<o>
Health: 75/100
Has shield: 1
Is healthy: 1
Can take damage: 1
```


These techniques help you:

- Understand which parts of a complex condition are `true` or `false`
- Identify unexpected values that might cause problems
- Make your debugging process more systematic
- Document your assumptions about what should happen

Remember that you can remove the debug print statements once you've fixed any issues - they're just temporary helpers for during development.

Debugging Complex Boolean Logic

<Excerpt>


In this lesson, we introduce the concept of booleans in C++. Booleans are one of the simplest 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 important because they are what drives 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 preview of how we can create booleans:


```c++
bool isAlive { true };
bool isDead { false };
```


In this lesson, we'll explore more on how to create, manipulate, and use these fundamental types.


</Excerpt>


<Ad />


## 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 check if two numbers are equal. When placed between the numbers, it will return the boolean value `true` if they are equal, and `false` otherwise.


```c++
int Level { 10 };

// Level is 10, so isLevel10 will be true
bool isLevel10 { Level == 10 };

// This will be false
bool isLevel15 { Level == 15 };
```


We can also compare two integer variables:


```c++
int Level { 20 };
int TargetLevel { 20 };

// This will be true
bool 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`.


```c++
int Level { 10 };
bool isNotLevel10 { Level != 10 }; // false
bool 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:


```c++
int Level { 10 };

bool isAboveLevel10 { Level > 10 }; // False
bool isAtLeastLevel10 { Level >= 10 }; // True

bool isBelowLevel10 { Level < 10 }; // False
bool isLevel10OrBelow { Level <= 10 }; // True
```


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


```c++
float Health { 100.0 };

// True
bool isHealthy { Health > 50.0 };

// True
bool isMaxHealth { Health >= 100 };
```


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


```c++
float Health { 100.0 };
float MaxHealth { 150.0 };

// True
bool isAbove50Percent { Health / MaxHealth > 0.5 };
```


<Quiz title="Simple Booleans">


<Question>


After running the following code, what will be the value of `MyBoolean`?


```c++
bool MyBoolean { 15 > 15 };
```


<Answer isCorrect>
The boolean value `false`
<Feedback>


You got it! Because we use the `>` operator, `15` would need to be greater than `15` for this expression to be `true`.  This is not the case - they're equal - so our result is `false`


</Feedback>


</Answer>


<Answer>


The boolean value `true`


<Feedback>


Consider how the `>` operator works. It evaluates if the left-hand side is greater than the right-hand side. Reflect on the values being compared here.


</Feedback>


</Answer>


</Question>


<Question>


After running the following code, what will be the value of `MyBoolean`?


```c++
bool MyBoolean { 15 >= 10 + 5 };
```


<Answer>
The boolean value `false`


<Feedback>


Think about what the **`>=`** operator signifies and how it compares the values on either side. Remember to consider the result of the expression `10 + 5`.


</Feedback>


</Answer>


<Answer isCorrect>


The boolean value `true`


<Feedback>


You got it! After the addition, our boolean will simplify to `15 >= 15`. Because `15` is equal to `15` and we're using the "greater than or equal to" operator, our final result is `true`.


</Feedback>


</Answer>


</Question>


</Quiz>


<Preview>


### Control Flow


Booleans are important as they unlock one of the key capabilities of programming - _**control flow**_.  This allows parts of our code to run only if some boolean condition is true.


The following program uses an `if` statement to output some text to the terminal only if the boolean expression `Health <= 0` is `true`.  The first time we evaluate this expression on line 8, it's `false`, so line 9 is ignored.


When we later evaluate it on line 13, it has become `true`, so our logging code is executed:


```c++
//<show-line-numbers>
#include <iostream>
using namespace std;

int main() {
  int Health{100};

  Health -= 50;
  if (Health <= 0) { // false //<h>
    cout << "I have been defeated";  //<h>
  }                                  //<h>

  Health -= 50;
  if (Health <= 0) { // true //<h>
    cout << "I have now been defeated";  //<h>
  }                                  //<h>
}
```


```c++
//<o>
I have now been defeated
```


We explore `if` statements and similar techniques in much more detail in the next chapter.


</Preview>


## Inverting Booleans with the `!` Operator


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


```c++
bool isAlive { true };
bool isDead { !isAlive }; // false
```


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


```c++
int Level = 10;
bool isAlive = true;

// This will be true
bool 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:


```c++
int Level = 10;

// This will be true
bool 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:


```c++
// true only if ALL conditions are true
Condition1 && Condition2 && Condition3;

// true if ANY condition is true
Condition1 || 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:


```c++
int Level = 10;
bool isDead { true };

// This will be true because Level == 10 is true
bool isMilestoneLevel {
  Level == 10 || Level == 20 || Level == 30
};

// This will be false because !isDead is false
bool canStartQuest {
  Level >= 10 && Level <= 20 && !isDead
};
```


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.


```c++
int Level { 10 };
bool isAlive { true };

// This will be true
bool isLevel10Or20AndAlive {
  (Level == 10 || Level == 20) && isAlive
};
```


<Ad />


<Aside>


### White Space


You may have noticed by now that how you space out your code is not important 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. White space is used only to make the code easier and faster for humans to read and understand.


Each developer and team will have their own opinions on how they like code to be formatted, but technically, we are mostly free to lay it out in whatever way we want:


```c++
// We can have multiple statements on one line
int Level { 10 }; int MaxLevel { 50 };

// We can have one statement across multiple lines
bool isAlive {
true
};

// When we do this, indenting can make things clearer
bool isImmortal {
  false
};

// Spacing a complicated statement across multiple
// lines can make it a bit easier to follow
bool isReady {
  Level == MaxLevel &&
  (isAlive || isImmortal) &&
  Health / MaxHealth > 0.5f
};
```


</Aside>


<Quiz title="Compound Booleans">


<Question>


If `Level` is an integer value, when is `isCorrectLevel` true after running the following code?


```c++
bool isCorrectLevel { Level < 10 && Level > 20 };
```


<Answer>
When `Level` is `5`
<Feedback>


Look at the condition stated. How does the `&&` operator work with the given numerical values? Reflect on the range of values where both conditions can be true.


</Feedback>


</Answer>


<Answer>


When `Level` is `15`


<Feedback>


Revisit the logic of `&&` and how it applies to the conditions specified. What does it mean for a number to be less than 10 and greater than 20 simultaneously?


</Feedback>


</Answer>


<Answer>


When `Level` is `25`


<Feedback>


Assess the logical expression again. Consider the individual parts of the expression and how they interact when combined with the `&&` operator.


</Feedback>


</Answer>


<Answer>


`isCorrectLevel` is always `true`


<Feedback>


Consider the logical implications of the statement. Can a number simultaneously satisfy both conditions given? Reflect on the nature of the `&&` operator.


</Feedback>


</Answer>


<Answer isCorrect>


`isCorrectLevel` is never `true`


<Feedback>


Correct! Because we're using the `&&` operator, both sides of our conditional need to be `true` for the overall value to be `true`. There is no possible number that is simultaneously less than `10` and greater than `20`


</Feedback>


</Answer>


</Question>


<Question>


After running the following code, what is the value of `isDead`?


```c++
int Health = 0;
bool isImmortal = false;
bool isDead { Health == 0 && !isImmortal };
```


<Answer isCorrect>
The boolean value `true`
<Feedback>


You got it! It can be helpful to simplify booleans step by step, eg, is `Health == 0` true? Is `isImmortal` true? What about `!isImmortal`?


</Feedback>


</Answer>


<Answer>


The boolean value `false`


<Feedback>


Examine each part of the expression separately. Think about the significance of `Health == 0` and the role of `!` before `isImmortal` in this context.


</Feedback>


</Answer>


<Answer>


This is invalid code


<Feedback>


Review the syntax used in the expression. Consider if there are any syntactical errors or if the code is logically coherent.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Common Mistakes - Not Repeating the Variable Name


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:


```c++
//<show-line-numbers>
int Level { 15 };

// This will be true
bool isReady { Level == 10 || 20 };//<w>
```


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`.


<Aside>


### Why is `20` considered `true`?


The previous assertion that `20` is true possibly confusing. Programming languages often allow other data types to be treated as booleans.  This behavior makes it easier for us to write conditional logic, which we'll introduce in the next chapter.


A value that will be `true` when used in a boolean context is often called _**"truthy"**_, whilst a value that will be converted to `false` is _**"falsy"**_ (or "falsey").


In C++ and most other programming languages, the integer value of `0` is falsy, whilst any other integer, such as `20`, is truthy.


</Aside>


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


```c++
int Level { 15 };

// This will now be false
bool isReady { Level == 10 || Level == 20 };//<h>
```


## Common Mistakes - Not Controlling the Order of Operations


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


```c++
//<show-line-numbers>
int Level { 10 };
bool isAlive { false };

// This will be true, because Level == 10
bool isReady {
  Level == 10 || Level == 20 && isAlive//<w>
};
```


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


```c++
Level == 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.


```c++
int Level { 10 };
bool isAlive { false };

// This will be false, because isAlive is false
bool isReady {
  (Level == 10 || Level == 20) && isAlive
};
```


## Common Mistakes - Using `&` and `|`


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.


```c++
bool A{1 & 2};//<w> // false
bool 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.


<History>


### George Boole (1815-1864)


Booleans are named after English mathematician George Boole.  This is why the word Boolean is sometimes capitalized as a proper noun.


Boole introduced what become known as Boolean algebra in his books _The Mathematical Analysis of Logic_ (1847) and _An Investigation of the Laws of Thought_ (1854).


</History>


## 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.

Fixed syntax error in one of the code examples

Fundamental Types (bool)

C++ Booleans

C++ - Boolean Types

4.8 - Boolean values

Logical Equivalence (AP/College Computer Science)

{CPP}Explore the world of Boolean logic in C++. This lesson covers everything from basic true/false concepts to complex Boolean operations.

{CPP}C++ Boolean Fundamentals: True & False Logic

Common Mistakes - Not Repeating the Variable Name

Common Mistakes - Not Controlling the Order of Operations

Booleans - `true` and `false` values

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers

Booleans - true and false values

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Questions & Answers

Booleans - `true` and `false` values