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

<Excerpt>


The ability to simulate randomness plays a surprisingly big role in creating software.  In the context of graphics, for example, we often use randomness to simulate natural phenomena, like wind and other random effects.


In a role-playing game, it can be used to implement things like:

- Loot Drops
- Damage Ranges
- Dodge Chances

We'll implement the last two of these in this lesson, in the context of a simple combat system.


</Excerpt>


We'll be able to write code like this, where our `Character` does between 15 and 25 damage on each attack, and has a 20% chance to dodge incoming damage:


```c++
class Character {
  // Each attack can do between 15 and 25 damage
  int MinDamage { 15 };
  int MaxDamage { 25 };

  // Character has a 20% chance to avoid damage
  float DodgeChance { 0.2 };

  int Health { 100 };

  void TakeDamage(int Damage) {
    if (Random::Bool(DodgeChance)) {//<h>
      return;
    }
    Health -= Damage;
  }

  void Act(Character* Target) {
    Target->TakeDamage(
      Random::Int(MinDamage, MaxDamage)//<h>
    );
  }
};
```


The new concepts here, and the key to getting this working, are these `Random::Int` and `Random::Bool` functions.


We'll create these functions in a file called `Random.h` that we can include in our other files as needed.    We will also wrap our code in a namespace:


```c++
// Random.h
#pragma once

namespace Random {
  // Our code here
}
```


## Generating a Random Number


Generating our random numbers involves 3 steps:

1. A _**seeder**_, that will create an initial "random" number for us
2. An _**engine**_, that will use the initial seed value to efficiently generate an endless supply of more random numbers
3. A _**distributor**_ that will convert these random numbers into the desired range, such as from 15 to 25 in our combat example

Let's get started!


<Ad />


## Seeding a Random Number Generator


The process of getting a random number from a computer is not as simple as it might seem.  Computers are, by design, deterministic machines.


Instead, how we simulate randomness is to source some unpredictable data, and then perform mathematical operations to convert that data to an unpredictable number.


This initial unpredictable input is called the **seed**.  In this lesson, we will simply ask the operating system to provide this seed.


To get access to this, we need to `#include` the `<random>` header from the standard library.  We can then create a variable of type `std::random_device`.


```c++
// Random.h
#pragma once
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;//<h>
}
```


<Aside>


### How does the Operating System Generate the Seed?


Operating systems have built-in techniques to generate random numbers.


How they do this varies, but typically, they combine data from a variety of places.  Common sources include things like:

- Timing data, like the time of the last 100 events of a specific type
- User input, like the pattern of recent mouse movement
- Arbitrary sensor data, like temperatures and ambient sound

These are commonly referred to as _**sources of entropy**_, and the operating system combines many of these sources to create a number that is so unpredictable it is effectively "random".
</Aside>


## Random Number Engines


The process of generating a seed is quite resource-intensive, so it is not something we want to do frequently.


Instead, the best practice is to take that seed and pass it into a random number engine that can quickly generate new numbers.  A common mathematical algorithm for doing this is called the [Mersenne Twister](https://en.wikipedia.org/wiki/Mersenne_Twister)


An implementation of this is available in the standard library, called `std::mt19937`.  We can initialize our engine using this algorithm, passing it a seed value generated from our seeder.


```c++
// Random.h
#pragma once
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;
  mt19937 engine { seeder() };//<h>
}
```


<Aside>


### Calling an Object


In the above example, the expression `seeder()` may seem weird.  `seeder` is an object of type `std::random_device`, but we appear to be calling it as if it were a function.


Based on what we've learned so far, we'd expect to call a function on an object, but not call an object directly.


The key to understanding what is happening here is that `()` is an **operator** in C++.  That means it can be overloaded within a class, and that's exactly what the developers who created `std::random_device` did.


This lets us create objects that have all the power of their classes but can also be used as if they were a function.  Such an object is sometimes called a _**function object**_ or a _**functor**_.  We cover functors in more detail, including how to create our own, in the next course.


</Aside>


## Random Number Distributions


Typically, when we are using randomness, we want it to be constrained to a certain range of possibilities. For example, we want a damage value to be somewhere between 15 and 25.


To do this, we need to remap the possible outputs from our random number engine to the values within this range. The standard library has `std::uniform_int_distribution` which can help us here.


To use it, we create an object of this type, calling the constructor with two integers - the lower and upper limit of the range.  Below, we've called our object `get`.  To generate a random number in this range, we then "call" `get`, passing in our engine:


```c++
std::uniform_int_distribution get { 1, 10 };

// Get a random integer from 1 to 10
get(engine);
```


Let's see all our components working together:


```c++
// Random.h
#pragma once
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;
  mt19937 engine{seeder()};

  int Int(int min, int max) {
    uniform_int_distribution get{min, max};
    return get(engine);
  }
}
```


<Error>


### Use of Class Template Requires Template Arguments


The previous code example may generate an error at `uniform_int_distribution`, particularly if you are using Visual Studio.  The syntax requires using the C++17 standard or later whilst, at the time of writing, Visual Studio uses C++14 by default.  That's quite old now, so updating it is recommended.


You can do this by opening the _Property Pages_ window (from the _View_ menu on the top bar) and setting the _C++ Language Standard_ within the _General_ section.  I'd recommend setting it to C++20 or later:


<Img file="vs-cpp-language-standard.png" alt="Screenshot showing C++ language standard configuration in Visual Studio" width="986" height="687" blurHash="L2R:HH00DgRN9I9FROIT00~po%tS" />


Alternatively, adding chevrons to `uniform_int_distribution` (and to `uniform_real_distribution`, which we'll use later) will make those examples compilable under older standards:


```c++
uniform_int_distribution get{min, max};//<d>
uniform_int_distribution<> get{min, max};//<h>
```


We cover what templates are, and what these chevrons represent, in the advanced course


</Error>


## Using our Random Number Generator


Now, within any of our other files, we can `#include` this header file, and start generating random integers.  We just need to call `Random::Int()` with a lower and upper limit.  Below, we log out three random numbers from 1-10:


```c++
// main.cpp
#include <iostream>
#include "Random.h"

int main() {
  std::cout << Random::Int(1, 10) << ", "//<h>
    << Random::Int(1, 10) << ", "//<h>
    << Random::Int(1, 10);//<h>
}
```


```c++
//<o>
5, 1, 7
```


Below, we use it in our `Character` class to make `Act()` inflict a random amount of damage based on the `MinDamage` and `MaxDamage` class variables:


```c++
// Character.h
#pragma once
#include "Random.h"

class Character {
  // Each attack can do between 15 and 25 damage
  int MinDamage { 15 };
  int MaxDamage { 25 };
  int Health{100};

  void TakeDamage(int Damage) {
    Health -= Damage;
  }

  void Act(Character* Target) {
    Target->TakeDamage(
      Random::Int(MinDamage, MaxDamage)//<h>
    );
  }
};
```


<Ad />


## Uniform and Normal Distributions


Here, we're using a uniform distribution, but other options are available.  In a **uniform distribution**, each number in the range is equally likely to be chosen.  In this example where our range is 15-25, a uniform distribution means that 15, 17, and 19 are going to be equally common results.


Another common strategy is to use a **normal distribution**.  In a normal distribution, the closer a number is to the center of the range, the more frequently it will be chosen.  In this example, that means 15 will rarely occur, 17 will be more common, and 19 will be chosen frequently.


If we choose 100 random integers from 15-25, the following chart shows how frequently we might expect each number to be chosen, depending on our choice of distribution:


<Img width="821" height="507" file="chart5.png" alt="Two charts showing a normal and uniform distribution" blurHash="LKSFw^kW%}aK_LaeR6j[NHoMs9oz" multiply />


## Random Booleans


A typical requirement we'll have is to trigger an event, but only sometimes.  For example, maybe a character dodges 20% of attacks, or performs a critical strike 10% of the time.


It would be useful to to encapsulate this within our `Random` namespace.  Let's use a different distributor function this time - `std::uniform_real_distribution` distributes our random numbers to a range of possible floating point numbers, rather than integers.


By distributing from `0.0` to `1.0`, and then comparing it to our desired probability, we can return `true` that proportion of the time.


Let's make this available as `Random::Bool()`:


```c++
#pragma once
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;
  mt19937 engine { seeder() };

  int Int(int min, int max) {
	  uniform_int_distribution get { min, max };
	  return get(engine);
  }

  bool Bool(float probability) {//<h>
	  uniform_real_distribution get { 0.0, 1.0 };//<h>
	  return probability > get(engine);//<h>
  }//<h>
}
```


Let's see it in action.  We'll loop 8 times and, on approximately 20% of those iterations, we'll log "Dodge" instead of "Hit":H


```c++
// main.cpp
#include <iostream>
#include "Random.h"

int main() {
  for (int i{0}; i < 8; ++i) {
    if (Random::Bool(0.2)) {//<h>
      std::cout << "Dodge, ";
    } else {
      std::cout << "Hit, ";
    }
  }
}
```


```c++
//<o>
Hit, Hit, Dodge, Hit, Hit, Hit, Hit, Dodge,
```


Using it on our class to prevent damage on approximately 20% of attacks would look like this:


```c++
// Character.h
#pragma once
#include "Random.h"

class Character {
  // Each attack can do between 15 and 25 damage
  int MinDamage { 15 };
  int MaxDamage { 25 };

  // Character has a 20% chance to avoid damage
  float DodgeChance { 0.2 };

  int Health{100};

  void TakeDamage(int Damage) {
    if (Random::Bool(DodgeChance)) {//<h>
      return; // Dodged!  No damage
    }
    Health -= Damage;
  }

  void Act(Character* Target) {
    Target->TakeDamage(
      Random::Int(MinDamage, MaxDamage)
    );
  }
};
```


<Ad />


## Controlling and Reproducing Randomness


When working with randomness, we often also want some visibility or control of what is happening.  For example, it can be difficult to reproduce a bug, or replay a sequence of events, if we have no control over the seed of our random number generator that was involved in those events.


Often, we may even want to give users control over the seed.  This is common in strategy games for example, where the map might be randomly generated, but we want users to be able to provide the seed.


This allows them to replay a map they enjoyed, or share it with their friends.  Without being able to control the seed, that is impossible.


Let's begin by updating our code to store the seed we use as a variable, so we can see what it is.  By using `auto` deduction or [checking a standard library reference](https://en.cppreference.com/w/cpp/numeric/random/random_device) we see that `random_device` returns an `unsigned int`.


We'll also add a `PrintSeed()` function, so we can see what value was chosen.


```c++
// Random.h
#pragma once
#include <iostream>
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;
  unsigned int seed { seeder() };//<h>
  mt19937 engine { seed };

  void PrintSeed() {
    cout << "Seed: " << seed << '\n';
  }

  int Int(int min, int max) {
    uniform_int_distribution get { min, max };
    return get(engine);
  }
}
```


And let's use it:


```c++
#include <iostream>
#include "Random.h"

int main() {
    using namespace std;
    Random::PrintSeed();
    cout << Random::Int(1, 100) << ", "
         << Random::Int(1, 100) << ", "
         << Random::Int(1, 100);
}
```


Running this code yields output similar to:


```c++
//<o>
Seed: 141102604
60, 78, 47
```


Of course, running the code a second time would generate a different output.  But, now that we know the seed, we could use that to get the same results again, if that is what we (or our user) wanted.


Let's add a `Reseed()` method to our `Random` namespace, which can be called any time we want to reproduce the same results:


```c++
// Random.h
#pragma once
#include <iostream>
#include <random>

namespace Random {
  using namespace std;
  random_device seeder;
  unsigned int seed { seeder() };
  mt19937 engine { seed };

  void PrintSeed() {
    cout << "Seed: " << seed << '\n';
  }

  void Reseed(unsigned int NewSeed) {//<h>
    seed = NewSeed;//<h>
    engine.seed(NewSeed);//<h>
  }//<h>

  int Int(int min, int max) {
    uniform_int_distribution get { min, max };
    return get(engine);
  }
}
```


Finally, let's make use of it in our code, to let us exert some control over our randomness:


```c++
#include <iostream>
#include "Random.h"

int main() {
  using std::cout;
  // We can still get random numbers:
  cout << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << "\n\n";

  // But now we can create reproducible results:
  Random::Reseed(141102604);
  Random::PrintSeed();
  cout << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << "\n\n";

  cout << "Let's go again - ";
  Random::Reseed(141102604);
  Random::PrintSeed();
  cout << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << ", "
       << Random::Int(1, 100) << "\n\n";
}
```


Our output is this:


```c++
//<o>
19, 4, 97

Seed: 141102604
60, 78, 47

Let's go again - Seed: 141102604
60, 78, 47
```


## Summary


In this lesson, we explored the fundamentals of implementing randomness in C++ by enhancing a simple combat system. We introduced the concepts of random number generators, distributions, and the practical application of these concepts in a game-like scenario.  The key topics we learned included:

- Understanding the role of randomness in software.
- Learning to implement random number generation in C++, including the use of `std::random_device`, `std::mt19937` (Mersenne Twister), and different types of distributions.
- Developing `Random::Int()` and `Random::Bool()` functions to generate random integers and booleans within specified ranges or probabilities.
- Grasping the importance of seeding in random number generation and how operating systems generate seeds from various sources of entropy.
- Gaining insights into controlling and reproducing randomness, including the use of seeds for debugging and creating repeatable scenarios in our programs.

<Preview>


### Dates, Times, and Durations


In our next lesson, we will explore how to handle dates and times in C++.  We'll investigate the `chrono` library, `std::time_t`, and the `tm` struct, all integral components for manipulating and representing time in various ways. The key topics we'll cover include:

- Introduction to the `chrono` library and its significance in modern C++ programming.
- Understanding `std::time_t` for representing time as a duration since the epoch.
- Exploring the `tm` struct for detailed time representation.
- Converting between different time formats using C++ functions.
- Practical examples demonstrating how to manipulate and format dates and times.

</Preview>

Added Error section for C++14 and older, and minor presentation improvements

3D art showing a character playing with dice

Pseudo-random number generation

Random

How to generate a random number in C++?

{CPP}Explore randomness in C++ programming, including random number generators, engines and distributions

{CPP}Learn Random Number Generation in C++

How does the Operating System Generate the Seed?

Use of Class Template Requires Template Arguments

Random Number Generation

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming