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

In the previous chapter, we saw how we could create user-defined types, helping us design our code in a way that makes sense for the specific project we're working on.


For example, were we making a game where players can fight goblin enemies, we could have a `Goblin` class, containing all our goblin-specific code:


```c++
class Goblin {
public:
  void Render(){}
  void Move(){}
  void Attack(){}
  void DropLoot(){}
  void Enrage(){}
};
```


When we start implementing more complex systems using classes, we quickly encounter a problem.  


## Why we need Inheritance


Our game will probably need some simple objects we can scatter around the environment, like rocks.


Rocks aren't as complicated as goblins.  They don't need to `Attack()` or `DropLoot()` - they just need to `Render()` themselves to the screen:


```c++
class Rock {
public:
  void Render(){}
};
```


We have a bit of a problem here - both of our classes have a `Render()` method.  In fact, given we're making a game, a lot of our types are going to need this method.


With what we've learned so far, there are no good ways to deal with this.  Some options might be:


### Option 1: Let Both Classes have a `Render()` Function


Having the same code in multiple places is a pain - it makes our projects very complicated.  Given we're making a game, a lot of our types are going to need this function, so the problem gets worse and worse as we add more types.


### Option 2: Repurpose the Goblin Class


Another option would be to make the `Goblin` class more general - we could call it something like `GameObject` and it could contain all the functionality any object might need.


This reduces the need to duplicate code, but it creates extremely complicated classes.  It also degrades performance - class functions like `Attack()` need class variables like `int Damage` to support those actions.  Having every rock in our game carry those variables, which they never need, is a waste of resources.


To solve this problem, what we need is the ability to define multiple layers of abstraction, and that is what **inheritance** gives us.


## Designing with Inheritance


Inheritance allows us to organize our classes into _**hierarchies**_.  This allows a class to inherit the functions and variables of its parent.


For example, let's imagine a class that simply grants the object the ability to exist in our world, and render itself to the screen.  We'll call this the `Actor` class.


<Img file="uml1.png" width="222" height="120" alt="A UML diagram showing the Actor class" blurHash="L9PjGcM{~q-;IUt7%MRj?bxuj[Rj" multiply />


Next, let's create a class for our Goblins.  Goblins also need the ability to be rendered, but with inheritance, we no longer need to recreate that functionality.  `Actor` already has that ability.


Goblins are just a more specific type of `Actor`, so we can have our `Goblin` class inherit all the abilities of the `Actor` class.


<Img file="uml2.PNG" width="426" height="356" alt="A UML diagram showing the Actor and Goblin classes" blurHash="L8Rp8-~q%M9Fof00t7_3Rj4nt7-;" multiply />


Now, our `Goblin` class has the `Render()` ability, without needing to write any additional code.  It just inherits it from the parent `Actor` class.


<Definition>


### Parents, Children, Subclasses, and Base Classes


Hierarchical structures like these are very common in programming.  There are many different terms used to describe the position of something within the hierarchy.


Phrases associated with family relationships are often used, such as _parent_, _child_, _ancestor_, _descendant,_ and more.  For example:

- `Actor` is a _parent_ or an _ancestor_ of `Goblin`
- `Goblin` is a _child_ or a _descendant_ of `Actor`

Other popular terms include _sub-class_, _base class,_ and _derived class_.  For example:

- `Goblin` is a _sub-class_ of `Actor`
- `Goblin` _derives from_ `Actor`
- `Actor` is the _base class_ of `Goblin`

</Definition>


This tree structure provides our classes with a powerful ability.  We get to have our dedicated, specific classes, but they don't need to duplicate the more generic, shared functions.


They can instead just inherit those functions and variables from their ancestors.


<Quiz title="Inheritance">


<Question>


What is inheritance?


<Answer>


Inheritance is how we can store multiple similar objects in the same memory location.


<Feedback>


Remember, inheritance in programming doesn't deal with memory locations but with relationships between classes. Think about how classes can share attributes and behaviors.


</Feedback>


</Answer>


<Answer>


Inheritance is a way we can combine different objects, to create more complex entities.


<Feedback>


We could manage complexity in this way. This is a technique called _object composition_ - but it is not the same as inheritance.


Inheritance focuses more on the relationship between classes and how one class can acquire properties from another.


</Feedback>


</Answer>


<Answer isCorrect>


Inheritance is how we can organize our classes into a hierarchy, such that child classes can inherit functionality from their ancestors.


<Feedback>


Exactly right! Inheritance allows us to create a hierarchy of classes where child classes inherit properties and methods from their parent classes, enabling code reuse and organization.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Implementing Inheritance


Let's create our `Actor` class, and our `Goblin` class that inherits from `Actor`.  To do this, we add some additional syntax to our `class Goblin` definition:


```c++
class Actor {
public:
  void Render(){};
};

class Goblin : public Actor {//<h>
public:  
  void Move(){}
  void Attack(){}
  void DropLoot(){}
  void Enrage(){}
};
```


<Aside>


### Public and Private Inheritance


Just like functions and variables, inheritance itself can be `public` or `private`. By default, class inheritance is `private`.  In our previous example, we set it to `public`.


The level of inheritance effectively sets the maximum visibility of any inherited functions.


Setting the inheritance to `public` will not overrule access restrictions within the base class. If something was `private` in `Actor`, it will still be private in `Monster`.


In practice, public inheritance is by far the most useful and most commonly used.  If you ever notice issues where the compiler is refusing to let you call a public inherited function, ensure the inheritance itself is also public.


</Aside>


Now, when we create an object from the `Goblin` class, that object will be both a `Goblin` and an `Actor`, able to use the functions of both:


```c++
Goblin Bonker;

// Available because Bonker is a Goblin
Bonker.Attack();

// Available because Bonker is an Actor
Bonker.Render();
```


With this class hierarchy, all `Goblin` objects are inherently also `Actor` objects.  The opposite is not necessarily true - an `Actor` is not necessarily a `Goblin`.


It could just be a plain `Actor`, or it could be some other subclass of `Actor`.


```c++
Actor Rock;

// Available because Rock is an Actor
Rock.Render();

// But we can't do this, because Rock is not a Goblin
Rock.Attack();//<e>
```


<Quiz title="Inheritance Relationships">


<Question>


Consider the following code:


```c++
class Item {};

class Weapon : public Item {};

int main(){
  Weapon IronSword;
}
```


What is `IronSword`?


<Answer>


The object is a `Weapon`, but not an `Item`


<Feedback>


Remember, in inheritance, a subclass is also an instance of its parent class. Consider how this applies to `Weapon` and `Item`.


</Feedback>


</Answer>


<Answer>


The object is an `Item`, but not a `Weapon`


<Feedback>


Think about the relationship between a parent and a child class in inheritance. Does creating an instance of the child class also mean it's an instance of the parent class?


</Feedback>


</Answer>


<Answer isCorrect>


The object is both a `Weapon` and an `Item`


<Feedback>


Correct!  When we use the `Weapon` class to create a new object, that object is going to have the `Weapon` type, as usual.


However, our classes have established a hierarchy, such that `Weapon` inherits from `Item`.


This means every object of type `Weapon` is also an `Item`


</Feedback>


</Answer>


<Answer>


`IronSword` is two objects - one is a `Weapon` and the other is an `Item`


<Feedback>


Inheritance doesn't create multiple separate objects, but a single object with combined characteristics.


</Feedback>


</Answer>


</Question>


<Question>


Consider the following code:


```c++
class Item {};

class Weapon : public Item {};

int main(){
  Item WoodenBarrel;
}
```


What is `WoodenBarrel`?


<Answer>


We cannot create an object using the `Item` class, as it is a base class. We need to use a specific child class.


<Feedback>


We can still create an object from a base class, even if a more specific child class is available.


</Feedback>


</Answer>


<Answer isCorrect>


The object is an `Item` but not a `Weapon`


<Feedback>


You got it!  Just because all `Weapon` objects are also `Item` objects, that doesn't mean that all `Item` objects are also `Weapon` objects.


If we create an object using the `Item` class it will be an `Item`, as well as every parent class of `Item`.


But it will not be a `Weapon`, or any other child class of `Item`


</Feedback>


</Answer>


<Answer>


The object is both a `Weapon` and an `Item`


<Feedback>


Consider the direction of the inheritance relationship. A child class inherits from a parent class, but does the reverse also apply?


</Feedback>


</Answer>


<Answer>


The object is neither an `Item` nor a `Weapon`


<Feedback>


The creation of an object using a class constructor indeed results in an object of that class. Reflect on how this applies to the `Item` class.


</Feedback>


</Answer>


</Question>


</Quiz>


<Ad />


## Multiple Layers of Inheritance


Let's add a new type of object to our game - we need dragons, so let's define a type, using the same approach:


<Img file="uml3.PNG" width="619" height="357" alt="A UML diagram showing the Actor, Goblin and Dragon classes" blurHash="L8RC[6~q_3Rj~q004nxu%M4nIUt7" multiply />


Something should seem off here.  The `Dragon` and `Goblin` classes both have the `Move()`, `Attack()`, and `DropLoot()` functions.  That's too much duplicate code.


Thankfully, with our new knowledge of inheritance, we might realize a way we can improve this design.


We can move that shared code into a new class.  We can then have both `Goblin` and `Dragon` inherit from it.  Let's call this new class `Character`


<Img file="uml4.PNG" width="843" height="448" alt="A UML diagram showing the Actor, Character, Goblin, and Dragon classes" blurHash="L5S6PlM{-;_3~q009FxuD%-;0000" multiply  />


Now, we have multiple layers of inheritance. With this setup, any `Goblin` or `Dragon` we create will be a member of 3 classes, inheriting the abilities of all of them:


```c++
class Actor {
public:
  void Render(){}
};

class Character : public Actor {
public:
  void Move(){}
  void Attack(){}
  void DropLoot(){}
};

class Goblin : public Character {
public:
  void Enrage(){}
};

class Dragon : public Character {
public:
  void Fly(){}
};

int main(){
  Dragon Dave;

  // Dave is an Actor
  Dave.Render();

  // And a Character
  Dave.Attack();

  // And a Dragon
  Dave.Fly();
}
```


## Preventing Inheritance with `final`


Sometimes, we create a class that is not designed to ever have a child class. To clarify that intent, and have the compiler enforce it, we can add the `final` specifier to the class heading:


```c++
class Demon final {};

// Combining final with a base class
class Vampire final : public Character {};
```


Should anyone try to inherit from a `final` class, the compiler will block them:


```c++
class Warrior : public Vampire {}//<e>
```


```c++
//<oe>
Cannot inherit from 'Vampire' as it has been declared as 'final'
```


## Summary


In this lesson, we explored the concept of inheritance in C++. We explored how inheritance allows us to create hierarchies of classes, enabling child classes to inherit properties and behaviors from their parent classes.


This not only helps in organizing code into a more understandable structure but also aids in reducing redundancy.  We:

- Learned the basics of inheritance and how it helps in organizing classes into hierarchies.
- Explored public and private inheritance, understanding how access levels affect the inherited members.
- Demonstrated the implementation of inheritance in C++ with practical examples, such as `Goblin` and `Actor` classes.
- Discussed the use of the `final` keyword to prevent further inheritance from a class.
- Examined multiple layers of inheritance through examples, showcasing how classes can inherit from other derived classes.

<Preview>


### Protected Class Members


Our next lesson will focus on protected class members. This concept helps us control access to class members in an inheritance hierarchy.


Protected members provide a level of accessibility that falls between `public` and `private`, which we'll cover in detail.


</Preview>

Combined and rewrote "Why we need Inheritance" and "Implementing Inheritance" lessons

Fixed error in the section explaining `final`

3D art showing a fantasy vampire character

Inheritance (object-oriented programming)

Friendship and inheritance

C++ Inheritance

{CPP}This C++ lesson introduces inheritance, teaching you to organize classes hierarchically

{CPP}Inheritance in C++: Simplifying Class Hierarchies

Option 1: Let Both Classes have a `Render()` Function

Parents, Children, Subclasses, and Base Classes

Inheritance

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming