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

The choice between angle brackets and quotes tells the compiler where to look for the header file. This is more than just a style choice - it affects how your program builds.


## Angle Brackets (`<>`)


When you use angle brackets, like `#include <iostream>`, the compiler looks in the system include directories. These are folders where standard C++ headers and third-party libraries are installed. The exact locations depend on your compiler and operating system, but they're typically somewhere like:

- `/usr/include` on Linux
- `C:\Program Files\Microsoft Visual Studio\...\include` on Windows

## Quotes (`""`)


When you use quotes, like `#include "Character.h"`, the compiler first looks in the same directory as your source file. If it can't find the header there, it then checks related directories in your project. Only if it still can't find the file will it look in the system directories.


Here's how you typically use each:


```c++
// System headers use angle brackets
#include <iostream>
#include <string>
#include <vector>

// Your own headers use quotes
#include "Character.h"
#include "Weapon.h"
```


The general rule is:

- Use angle brackets for headers that come with C++ or third-party libraries
- Use quotes for headers you've created as part of your project

Following this convention makes your code more maintainable because other developers can quickly understand where each header comes from. It also helps the compiler work more efficiently since it knows where to look first.

Header File Syntax: `<>` vs `""`

This is a common source of confusion! Even though the CPP file contains the implementations of our class functions, we still need to include the header. Here's why:


## The Compiler Needs the Class Definition


When we define member functions in a CPP file, we need to tell the compiler these functions belong to our class. The compiler needs to know:

- What class these functions belong to
- What member variables exist in the class
- What access specifiers (`public`, `private`) apply to each member

Let's see what happens if we don't include the header:


```c++
// Character.cpp
void Character::TakeDamage(int Damage) {//<e>
  Health -= Damage;//<e>
}
```


```plain text
//<oe>
error: 'Character' has not been declared
error: 'Health' was not declared in this scope
```


Here's the correct way:


```c++
// Character.h
class Character {
public:
  void TakeDamage(int Damage);
private:
  int Health{100};
};
```


```c++
// Character.cpp
#include "Character.h"

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


## It Helps Catch Errors


Including the header also helps us catch errors. If our implementation doesn't match the declaration in the header, we'll get a compiler error. For example:


```c++
// Character.h
class Character {
public:
  void TakeDamage(int Damage);
};
```


```c++
// Character.cpp
#include "Character.h"

void Character::TakeDamage(float Damage) {//<e>
  Health -= Damage;
}
```


```plain text
//<oe>
error: parameter type mismatch
note: previous declaration was 'void Character::TakeDamage(int)'
```


This helps us maintain consistency between our header and implementation files.

Including Headers in CPP Files

Yes, you can have circular dependencies when using pointers! This is one of the main reasons we use pointers in C++. Let's break down how and why this works.


## Why Pointers Are Special


When we use a pointer, the compiler only needs to know that the type exists - it doesn't need to know the full details of the type. This is because all pointers have the same size in memory, regardless of what they point to.


Here's a working example:


```c++
// Sword.h
#pragma once
class Character;// Forward declaration

class Sword {
public:
  void SetWielder(Character* NewWielder);
  Character* GetWielder() { return Wielder; }
private:
  Character* Wielder{nullptr};
  int Damage{10};
};
```


```c++
// Character.h
#pragma once
class Sword;// Forward declaration

class Character {
public:
  void EquipWeapon(Sword* NewWeapon);
  Sword* GetWeapon() { return Weapon; }
private:
  Sword* Weapon{nullptr};
  int Health{100};
};
```


```c++
// Character.cpp
#include "Character.h"
#include "Sword.h"// Full header needed here

void Character::EquipWeapon(Sword* NewWeapon) {
  if (Weapon) {
    // Tell old weapon it's no longer equipped
    Weapon->SetWielder(nullptr);
  }
  Weapon = NewWeapon;
  if (NewWeapon) {
    // Tell new weapon who is wielding it
    NewWeapon->SetWielder(this);
  }
}
```


## Why It Doesn't Work Without Pointers


If we tried to use actual objects instead of pointers, we'd have a problem:


```c++
class Sword {
  // Not a pointer!
  Character Wielder;//<e>
};
```


```c++
class Character {
  // Not a pointer!
  Sword Weapon;//<e>
};
```


```plain text
//<oe>
error: incomplete type 'Character' used in nested name specifier
error: incomplete type 'Sword' used in nested name specifier
```


This fails because to create a `Character`, we need to know how big a `Sword` is. But to know how big a `Sword` is, we need to know how big a `Character` is! It's a chicken-and-egg problem that pointers solve for us.

Circular Dependencies

The compiler follows specific rules to find header files, and we can configure additional search paths. Let's break this down:


## Default Search Locations


When looking for headers, the compiler checks several places in this order:


For quoted includes (`#include "file.h"`):

- The same directory as the source file
- The project's include directories
- The system include directories

For angle bracket includes (`#include <file.h>`):

- The system include directories only

## Adding Include Directories


Most IDEs let you specify additional include directories. In Visual Studio:


```c++
// Project structure:
MyGame/
  Source/
    Player/
      Player.cpp
    Weapons/
      Sword.h
```


If `Player.cpp` needs to include `Sword.h`, we have options:


```c++
// Option 1: Relative path (fragile)
#include "../Weapons/Sword.h"//<w>

// Option 2: Add include directory
#include "Sword.h" // Better! //<h>
```


## Setting Up Include Directories


In Visual Studio:

1. Right-click your project
2. Select _**Properties**_
3. Navigate to _**C/C++  General**_
4. Add your paths to _**Additional Include Directories**_

For example, adding `$(ProjectDir)Source` lets you include files from anywhere in the `Source` directory.


## Example Project Structure


Here's a common way to organize files:


```c++
MyGame/
  Include/
    Character.h
    Weapon.h
    Items/
      Potion.h
  Source/
    Character.cpp
    Weapon.cpp
    Items/
      Potion.cpp
```


With `Include` added to our include directories, we can write:


```c++
// From Include/
#include "Character.h"

// From Include/Items/
#include "Items/Potion.h"
```


This makes our includes cleaner and more maintainable, and lets us move files around without breaking includes.

Header File Locations

`#pragma once` prevents a header file from being included multiple times in the same translation unit. This is important because multiple inclusions can cause compilation errors and slow down compilation.


## The Problem


Without `#pragma once`, this situation can happen:


```c++
// Weapon.h
class Weapon {
  int Damage{10};
};
```


```c++
// Character.h
#include "Weapon.h"//<h>

class Character {
  Weapon* MainWeapon;
};
```


```c++
// Game.cpp
#include "Weapon.h"//<h>
#include "Character.h"//<h>

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


The `Game.cpp` file ends up with two copies of the `Weapon` class definition:

1. Directly from `#include "Weapon.h"`
2. Indirectly when `Character.h` includes `Weapon.h`

This creates a compiler error:


```plain text
//<oe>
error: redefinition of 'class Weapon'
```


## The Solution


Adding `#pragma once` fixes this:


```c++
// Weapon.h
#pragma once//<h>

class Weapon {
  int Damage{10};
};
```


Now the compiler only includes the file once, no matter how many times it appears in include statements.


## The Alternative


Before `#pragma once`, we used include guards:


```c++
// Weapon.h
#ifndef WEAPON_H//<h>
#define WEAPON_H//<h>

class Weapon {
  int Damage{10};
};

#endif//<h>
```


Both approaches work, but `#pragma once` is:

- Shorter and cleaner
- Less prone to naming conflicts
- Often faster for the compiler

That's why `#pragma once` is now the preferred choice in modern C++, even though include guards are still common in older code and some cross-platform projects.

Understanding `#pragma once`

Yes, you can declare multiple classes in one header file! While the convention is one class per file, there are good reasons to group related classes together.


## When to Group Classes


Good reasons to put multiple classes in one header:

- Small helper classes that are only used by the main class
- Closely related classes that always work together
- A set of classes that form a cohesive feature

Here's an example:


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

class Item {
public:
  virtual int GetValue() = 0;
};

class InventorySlot {
  Item* StoredItem{nullptr};
  int Quantity{0};
public:
  void Store(Item* NewItem) {
    StoredItem = NewItem;
    Quantity = 1;
  }
  Item* GetItem() { return StoredItem; }
};

class Inventory {
  static const int MaxSlots{20};
  InventorySlot Slots[MaxSlots];
public:
  bool AddItem(Item* NewItem);
  Item* GetItem(int SlotIndex);
};
```


## When to Separate Classes


You should create separate header files when:

- Classes are used independently
- Classes are large or complex
- Classes might be reused in different contexts
- Different teams work on different classes

Example of when to separate:


```c++
// Weapon.h
#pragma once
class Weapon {
  int Damage{10};
public:
  int GetDamage() { return Damage; }
};
```


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

class Character {
  Weapon* EquippedWeapon{nullptr};
public:
  void EquipWeapon(Weapon* NewWeapon) {
    EquippedWeapon = NewWeapon;
  }
};
```


## Guidelines


Consider these factors:

- Will other developers expect to find these classes together?
- Does it make sense to reuse one class without the others?
- Would separating the files make the code harder to understand?
- Is the header file getting too large to manage easily?

Remember, these are guidelines, not strict rules. Use your judgment based on your specific situation.

Multiple Classes Per Header

This is a balance between code organization, compilation speed, and developer convenience. Let's look at when to separate definitions and when to keep them together.


## When to Keep Definitions in Headers


Good candidates for keeping in headers:

- One-line functions
- Simple getters and setters
- Template functions (these usually must be in headers)
- Heavily inlined functions for performance

Example of appropriate header-only functions:


```c++
// Character.h
class Character {
public:
  // Simple getter - fine in header
  int GetHealth() { return Health; }

  // Simple setter - fine in header
  void SetName(const std::string& NewName) {
    Name = NewName;
  }

  // Simple calculation - fine in header
  bool IsAlive() { return Health > 0; }

private:
  int Health{100};
  std::string Name;
};
```


## When to Move to CPP Files


Move functions to CPP files when they:

- Have complex logic
- Might change frequently
- Use many external dependencies
- Are several lines long

Example of functions to move:


```c++
// Character.h
class Character {
public:
  void TakeDamage(int Damage);
  void UseHealthPotion(int PotionStrength);
private:
  int Health{100};
};
```


```c++
// Character.cpp
#include "Character.h"

// Complex functions often need more headers
#include <algorithm>

void Character::TakeDamage(int Damage) {
  // Complex logic belongs in cpp files
  if (IsInvulnerable()) { return; }

  int ActualDamage =
    CalculateDamageReduction(Damage);
  Health = std::max(0, Health - ActualDamage);

  if (Health <= 0) { OnDeath(); }
}

void Character::UseHealthPotion(
  int PotionStrength) {
  // Multi-line functions are better in cpp files
  if (Health <= 0) { return; }

  Health = std::min(
    100, Health + PotionStrength);
  OnHealthChanged();
}
```


## Guidelines


Consider these factors:

- Will changing this function require recompiling many files?
- Is the function so simple that separating it makes code harder to follow?
- Would other developers expect to see this implementation in the header?
- Does the function use many headers that would otherwise not be needed?

Remember, these are guidelines rather than strict rules. Use your judgment based on your specific needs.

Separating Declarations

Improved introduction (added "Multiple Source Files" section)

C++ Standard Library Headers

Understanding C++ Linker

Forward declarations

{CPP}A comprehensive guide to c++ forward declaration, header files, and the linker

{CPP}C++ for Beginners: Understanding Headers & Linkers

Namespaces, Enums, and `using` Statements

Header Files

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers