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

Before we introduce the next topic, let's take some time to explain the goal.


Ambitious projects can have a lot of systems, and those systems manage complex interactions between objects.


Those systems also often need to support different types of objects, each of which can behave in slightly different ways.


In the context of a game, for example, that might include:

- lots of enemy types to fight in our combat system
- lots of quests to do in our questing system
- lots of items to select from for our equipment system

We need ways to implement all this variety, without our code getting so complex it becomes unmanageable.


## An Example Use Case


Let's take our hypothetical combat system.  We want our game to support a large range of enemy types, each being capable of having their unique ways of fighting.


Goblins might charge in and attack at close range.  Archers might stand back and fight from range.  Dragons might take to the skies.


We don't want to define all those behaviors within the combat system.  That would cause the system to get unmanagably complex, and more complex with every new enemy type we add.


Instead, our project is much more manageable if we _**encapsulate**_ those behaviors within the respective classes.  Our dragons' behaviors should be in the `Dragon` class, goblin logic belongs in the `Goblin` class, and so on.


<Ad />


## Run Time Polymorphism


In our hypothetical system, the player can run around and choose what enemies to battle with.  Therefore, every time our combat system gets used, we don't necessarily know the types that will be involved.


That is determined by player actions, at run time.  Maybe the player will fight some goblins first, or maybe they'll go for the dragon.  So, we need _**run time polymorphism**_.


In C++, this is achieved by a combination of three techniques, two of which we're already familiar with:

- Inheritance
- References and Pointers
- Virtual Functions

Let's see how we might combine these concepts to create the essence of a polymorphic combat system


## Step 1: Inheritance


The first step of the process is establishing a base class, from which all of our combat participants will inherit.  In this example, we'll call our base class `Character`, and we'll provide an `Act()` function, which will represent a combat action.


Any time we want our character to do something, we'll call `Act()`, and we'll pass in a pointer to the target that our character is fighting:


```c++
class Character {
public:
  void Act(Character* Target) {
    cout << "Character Acting\n";
  }
};
```


Then, every type of object that we want to be able to participate in our combat system, such as goblins and dragons, will inherit from this base class:


```c++
//<c name="Character Class (Unchanged)">
//<l>class Character {/*...*/};
class Character {
public:
  void Act(Character* Target) {
    cout << "Character Acting\n";
  }
};
//</c>

class Goblin : public Character {};//<h>

class Dragon : public Character {};//<h>
```


## Step 2: References and Pointers


For the next step, we set up our systems to work with references or pointers to this shared base `Character` type.


In this example, we'll represent our combat system as a simple function called `Battle`.  The `Battle` function receives two `Character` pointers, and has them `Act()` upon each other:


```c++
void Battle(Character* A, Character* B) {
  A->Act(B);
  B->Act(A);
}
```


Remember, under the rules of inheritance, Goblins and Dragons are Characters.  So each of these pointers could be pointing at a basic `Character`, a `Dragon`, a `Goblin`, or any other subtype of `Character` we add in the future.


So far, so good.  Below, a `Goblin` and a `Dragon` enter battle, and both of our combatants are using the `Act()` function defined on the basic `Character` class:


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

//<c name="Character Class (Unchanged)">
//<l>class Character {/*...*/};
class Character {
public:
  void Act(Character* Target) {
    cout << "Character Acting\n";
  }
};
//</c>

class Goblin : public Character {};

class Dragon : public Character {};

void Battle(Character* A, Character* B){
  A->Act(B);
  B->Act(A);
}

int main(){
  Goblin A;//<h>
  Dragon B;//<h>
  Battle(&A, &B);//<h>
}
```


```c++
//<o>
Character Acting
Character Acting
```


## Step 3: Virtual Functions


We want function calls like `A->Act()` to have different effects, depending on which subtype of character `A` is pointing at.  For example, if `A` is a `Goblin`, the effect of this function call will be different than if `A` were a `Dragon`.


To achieve this, we need to provide `Goblin` and `Dragon`-specific implementations of the `Act()` function, using the same prototype as `Act()` within the `Character` class.


This is referred to as _**overriding**_ the function:


```c++
class Goblin : public Character {
public:
  void Act(Character* Target){//<h>
    cout << "Goblin Acting\n";//<h>
  }//<h>
};

class Dragon : public Character {
public:
  void Act(Character* Target){//<h>
    cout << "Dragon Acting\n";//<h>
  }//<h>
};
```


Then, we need to mark the `Character` version of this function as `virtual`.  We cover the significance of the `virtual` keyword in the next section:


```c++
class Character {
public:
  virtual void Act(Character* Target){//<h>
    cout << "Character Acting\n";
  }
};
```


With everything in place, we've now achieved run-time polymorphism.  Without changing any code in our `Battle` function, its behavior is now dynamic:


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

class Character {
public:
  virtual void Act(Character* Target){
    cout << "Character Acting\n";
  }
};

class Goblin : public Character {
public:
  void Act(Character* Target){
    cout << "Goblin Acting\n";
  }
};

class Dragon : public Character {
public:
  void Act(Character* Target){
    cout << "Dragon Acting\n";
  }
};

void Battle(Character* A, Character* B){
  A->Act(B);
  B->Act(A);
}

int main(){
  Goblin A;
  Dragon B;
  Battle(&A, &B);
}
```


```c++
//<o>
Goblin Acting
Dragon Acting
```


## Expanding the System


With the basic system in place, we're now free to expand it as needed, whilst keeping the complexity under control.


We can add _**depth**_ by expanding the core system - that is, by expanding the `Character` class and the `Battle` function.


For example, we introduce the concept of characters being alive or dead below, with battle continuing until one of our combatants is dead:


```c++
class Character {
public:
  virtual void Act(Character* Target){
    cout << "Character Acting\n";
  }

  bool GetIsAlive(){ return isAlive; }//<h>

protected:
  bool isAlive{true};//<h>
};

void Battle(Character* A, Character* B){
  while (A->GetIsAlive() && B->GetIsAlive()) {//<h>
    A->Act(B);//<h>
    B->Act(A);//<h>
  }//<h>
}
```


We can add _**breadth**_ by adding more and more enemy types, without our combat system getting more and more complex.  Our types just inherit from `Character` and override functions as needed.


Remember, we can use multiple layers of inheritance if needed.  Our types don't always need to inherit from `Character` directly:


```c++
class Character {};
class Dragon : public Character {};
class FireDragon : public Dragon {};
class FrostDragon : public Dragon {};
class StormDragon : public Dragon {};
```


This pattern keeps our project organized and manageable, even as we scale up to hundreds or even thousands of types.


Our source code file might get a little large, but in the next chapter, we'll see how we can split our project across multiple files.


This allows us to keep types in dedicated files like `Dragon.cpp` and `Goblin.cpp`, helping us keep things organized as our classes get larger and more powerful.


## Early and Late Binding


The inclusion of the `virtual` keyword in our class function changes calls to that function from being _**statically bound**_ to being _**dynamically bound**_.


We can think of binding as being how the compiler links an expression that invokes a function, like `Act()`, to where that function is defined in our source code, such as the `Act` function in our `Character` class.


By default, C++ binds our function calls to the function definitions in our code at compile time.  This is sometimes referred to as _**static binding**_, or _**early binding**_.


In other words, when the compiler sees an expression like `A->Act()`, it investigates the type of `A`.  In our `Battle` function, `A` is a `Character`, so the compiler simply associates this call to the `Act()` function as defined within the `Character` class.


### What Does the `virtual` Keyword Do?


By adding the `virtual` specifier, we're asking the compiler to take a different approach.  When we call a `virtual` function, the compiler determines what specific type of object our pointer is pointing at.


It then calls the version of the function within that type.  If that type doesn't define it, we then search up the inheritance tree until we find the nearest ancestor that does.


However, the compiler doesn't know the exact subtype of `Character` our battle function is dealing with.  That depends on what the player chooses to fight.  Therefore, the compiler doesn't know which `Act()` function to bind to.


That information isn't known until the player starts fighting something.  Therefore, virtual functions can only be selected at run time.  This is referred to as _**dynamic binding**_, or _**late binding**_.


Dynamic binding has a small performance impact at run time, which is why it is not used by default.  When we need a function to behave this way, we have to explicitly opt in, by marking it as `virtual`


<Quiz title="The `virtual` specifier">


<Question>


What is the effect of the `virtual` specifier?


<Answer isCorrect>


It means that, when the function is called, the compiler will use the "most derived" version of that function.


<Feedback>


Correct! The `virtual` specifier enables dynamic binding, allowing the program to select the most appropriate version of the function at runtime based on the object's actual type.


</Feedback>


</Answer>


<Answer>


It means that the function cannot be called - we must instead override it in a derived class.


<Feedback>


This is true of "pure virtual" functions which we will cover in the next course - but a `virtual` function can still be invoked.


The key aspect of a `virtual` function is its role in runtime polymorphism.


</Feedback>


</Answer>


<Answer>


It means that this function is overriding a function on a class it inherits from.


<Feedback>


Think about how `virtual` functions enable polymorphic behavior. They can be overridden, but they don't need to be an override.


</Feedback>


</Answer>


</Question>


</Quiz>


## The `override` Specifier


When a class function is supplanting a virtual method on a base class in this way, it is considered an _**override**_. 


When we're overriding something, we should be explicit, by marking our function with the `override` keyword:


```c++
class Goblin : public Character {
public:
  void Act(Character* Target) override {//<h>
    cout << "Goblin Acting!\n";
  }
};
```


This is _**not required**_, but we should use it where applicable.  It has two benefits:

- It informs other developers reading our function that it is an override
- The compiler ensures that our function really is overriding something.  That is, it ensures there is a virtual function on a base class with the same prototype.

This second point is especially useful when we come back to update our code in the future.  If we change the name or parameters of a function, any child class that was overriding it no longer will be, because the prototype will now be different.


By adding the `override` specifier, the compiler will detect that issue, and alert us.  This lets us ensure we update those child classes too, preventing any bugs.


<Quiz title="The `override` specifier">


<Question>


What is the effect of the `override` specifier?


<Answer>


We need to add `override` to ensure late binding works correctly when we call the overridden function.


<Feedback>


The specifier is optional, even for an override function.  The presence or absence of the specifier doesn't effect binding


</Feedback>


</Answer>


<Answer isCorrect>


It causes the compiler to ensure the function is overriding a function on a base class.


<Feedback>


Exactly right! The `override` specifier helps ensure that the function is indeed overriding a method in a base class, providing both clarity and a compiler check.


</Feedback>


</Answer>


<Answer>


It means that if we change the prototype of our base function, the override function is updated automatically.


<Feedback>


The `override` specifier will alert us if the prototype of the base function has changed, but it will not fix it for us automatically.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Preventing Overrides using `final`


When our code encounters a virtual function, the process of traversing the inheritance tree to find the most derived override effectively treats all intermediate functions as virtual, too.


This is the case whether they are marked as `virtual` or not.  In some scenarios, we may need to design our class in such a way that subtypes should not be able to override a function.


In those cases, we can mark the function as `final`.


Below, our `Goblin` class doesn't want any subtypes from overriding `Act()`, so it marks it as `final`.  When `GoblinWarrior` tries, the compiler generates an error:


```c++
class Character {
public:
  virtual void Act(){} //<h>
};

class Goblin : public Character {
public:
  void Act() final{} //<h>
};

class GoblinWarrior : public Goblin {
public:
  void Act() override{} //<e>
};
```


```c++
//<o>
error:
'Goblin::Act': function declared as 'final'
cannot be overridden by 'GoblinWarrior::Act'
```


<Quiz title="The `final` specifier">


<Question>


What is the effect of the `final` specifier?


<Answer isCorrect>


It prevents any child classes from overriding that function.


<Feedback>


Correct! The `final` specifier is used to prevent further overriding of a function in derived classes, ensuring the integrity of your method's implementation.


</Feedback>


</Answer>


<Answer>


A class that inherits from this class must override any functions marked `final`.


<Feedback>


Reflect on the purpose of `final` in controlling overrides and how it affects the behavior of derived classes.


</Feedback>


</Answer>


<Answer>


A class that has any of its functions marked as `final` cannot have child classes.


<Feedback>


We can still inherit from classes that have some of their functions marked as `final`.  Think about the specific impact of `final` on functions within a class, rather than on the inheritance capabilities of the class itself.


</Feedback>


</Answer>


</Question>


</Quiz>


## Slicing


It is worth noting that this form of run-time polymorphism only works when we're passing our objects by _**reference**_ or _**pointer**_.


The following code creates a `Goblin` object and then passes that object by **value** to a `Character` parameter:


```c++
class Character {};

class Goblin : public Character {
 public:
  int Damage{10};
};

void Battle(Character Enemy){//<h>
  // Enemy is always a basic Character  
}

int main() {
  Goblin Bonker;
  Battle(Bonker);
}
```


An object of a subtype can be copied to an object of a base type, and that's what has happened here. Within the `Battle()` function, `Enemy` is not a `Goblin`.  It is a basic `Character`.


Even though `Enemy` was copied **from** a `Goblin`, it was copied **into** a plain old `Character` container.  To accommodate this, the goblin-specific data (`Damage`, in this case) was chopped off and only the `Character` variables were kept.


This scenario is sometimes referred to as _**slicing**_.  There are legitimate use cases where we may want to do this, but it's frequently a bug.


## Summary


In this lesson, we explored the powerful concept of virtual functions and overrides, which are essential for implementing runtime polymorphism. Here are the key takeaways:

- **Virtual Functions**: Virtual functions enable runtime polymorphism, allowing subclasses to provide specific implementations for functions declared in a base class.
- **Inheritance and Polymorphism**: Using inheritance, we can create a hierarchy of classes where derived classes can override the behavior of base class functions.
- **Override Keyword**: The **`override`** keyword, while not mandatory, clarifies that a function is intended to override a base class function and ensures safety by enabling compiler checks.
- **Final Specifier**: The **`final`** specifier is used to prevent further overriding of a method in any subclass, ensuring that the function behavior remains consistent in the inheritance hierarchy.
- **Object Slicing**: We learned about object slicing, a phenomenon where a derived class object is treated as a base class object, leading to the potential loss of derived class information.

<Preview>


### Downcasting


In our next lesson, we will explore the concepts of downcasting and dynamic casting. Here's what we'll cover:

- **Understanding Downcasting**: We'll explain what downcasting is and why it's sometimes necessary, particularly in the context of polymorphism.
- **Dynamic Casting**: We'll explore dynamic casting, a safe way to perform downcasting, and understand how it differs from static casting.
- **Risks and Considerations**: We'll discuss the potential risks and limitations associated with downcasting, emphasizing the importance of using it judiciously.
- **Practical Scenarios**: By examining real-world scenarios, we'll demonstrate where and why downcasting is used in programming.
- **Syntax and Usage**: We'll break down the syntax of `dynamic_cast` and show how to use it effectively in your code.

</Preview>

Virtual Functions - C++ Reference

Polymorphism in Object-Oriented Programming

Understanding Virtual Functions in C++

FAQs on Virtual Functions in C++

{CPP}Using virtual functions and overrides in C++ to implement run-time polymorphism

Virtual Functions and Overrides

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming