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 Singleton pattern ensures a class has only one instance and provides a global point of access to it. We can use the `this` pointer to implement this pattern in C++. Here's how:


```c++
#include <iostream>

class Singleton {
 private:
  static Singleton* instance;

  // Private constructor to prevent instantiation
  Singleton() {}

 public:
  // Delete copy constructor and assignment operator
  Singleton(const Singleton&) = delete;
  Singleton& operator=(const Singleton&) = delete;

  static Singleton* getInstance() {
    if (instance == nullptr) {
      instance = new Singleton();
    }
    return instance;
  }

  void someBusinessLogic() {
    std::cout << "Singleton is doing something.\n";
  }

  // Use this pointer to provide instance methods
  Singleton* doSomething() {
    std::cout << "Did something and "
      "returning this.\n";
    return this;  //<h>
  }

  Singleton* doSomethingElse() {
    std::cout << "Did something else and "
      "returning this.\n";
    return this;  //<h>
  }
};

// Initialize the static member
Singleton* Singleton::instance = nullptr;

int main() {
  Singleton* s = Singleton::getInstance();
  s->someBusinessLogic();

  // Chain method calls using 'this'
  s->doSomething()->doSomethingElse();

  return 0;
}
```


```plain text
//<o>
Singleton is doing something.
Did something and returning this.
Did something else and returning this.
```


In this implementation, we use the `this` pointer in two ways:

1. To implement the Singleton pattern itself: The `getInstance()` method creates the single instance if it doesn't exist, and returns a pointer to it.
2. To enable method chaining: The `doSomething()` and `doSomethingElse()` methods return `this`, allowing us to chain these method calls.

By returning `this`, we're returning a pointer to the current instance, which allows us to call another method on the same instance immediately. This creates a fluent interface, making the code more readable and expressive.


Remember, the Singleton pattern should be used sparingly, as it can make your code harder to test and maintain. However, it can be useful in scenarios where you need to ensure that a class has only one instance throughout the application's lifecycle, such as for managing a shared resource or coordinating actions across the system.

Implementing the Singleton Pattern

The Composite pattern is used to compose objects into tree structures to represent part-whole hierarchies. It lets clients treat individual objects and compositions uniformly. Let's implement this pattern using the `this` pointer in C++:


```c++
#include <iostream>
#include <memory>
#include <vector>

class Component {
 public:
  virtual ~Component() = default;
  virtual void operation() = 0;
  virtual void add(
    std::shared_ptr<Component> component) {}
  virtual void remove(
    std::shared_ptr<Component> component) {}
  virtual Component* getChild(int index) {
    return nullptr;
  }
};

class Leaf : public Component {
 public:
  void operation() override {
    std::cout << "Leaf operation\n";
  }
};

class Composite : public Component {
 private:
  std::vector<std::shared_ptr<Component>> children;

 public:
  void operation() override {
    std::cout << "Composite operation\n";
    for (const auto& child : children) {
      child->operation();
    }
  }

  void add(
    std::shared_ptr<Component> component
  ) override {
    children.push_back(component);
  }

  void remove(
    std::shared_ptr<Component> component
  ) override {
    // Removal logic (omitted for brevity)
  }

  Component* getChild(int index) override {
    return children[index].get();
  }

  // Using 'this' for method chaining
  Composite* addAndReturnThis(
    std::shared_ptr<Component> component
  ) {
    add(component);
    return this;  //<h>
  }
};

int main() {
  auto root = std::make_shared<Composite>();
  auto branch1 = std::make_shared<Composite>();
  auto branch2 = std::make_shared<Composite>();
  auto leaf1 = std::make_shared<Leaf>();
  auto leaf2 = std::make_shared<Leaf>();
  auto leaf3 = std::make_shared<Leaf>();

  root->addAndReturnThis(branch1)
    ->addAndReturnThis(branch2);  //<h>

  branch1->add(leaf1);
  branch2->addAndReturnThis(leaf2)
    ->addAndReturnThis(leaf3);

  root->operation();
}
```


```plain text
//<o>
Composite operation
Composite operation
Leaf operation
Composite operation
Leaf operation
Leaf operation
```


In this implementation, we use the `this` pointer in the `addAndReturnThis()` method of the `Composite` class. This method adds a component to the composite and then returns `this`, allowing for method chaining.


The `this` pointer is crucial here because:

1. It allows us to return a pointer to the current instance (`Composite*`).
2. This enables method chaining, making our client code more readable and concise.

In the `main()` function, we demonstrate how this method chaining works:


```c++
root->addAndReturnThis(branch1)
    ->addAndReturnThis(branch2);
```


This line adds `branch1` to `root`, then immediately adds `branch2` to `root` as well.


Similarly, we can chain multiple `addAndReturnThis()` calls on `branch2`:


```c++
branch2->addAndReturnThis(leaf2)
       ->addAndReturnThis(leaf3);
```


This pattern is particularly useful when you're dealing with tree-like structures, such as GUI components, file systems, or organizational hierarchies. It allows you to treat complex and primitive objects uniformly, simplifying client code.

Implementing the Composite Pattern

When working with multi-threaded environments in C++, using the `this` pointer requires careful consideration to ensure thread safety. Here are some best practices:


## 1. Avoid Returning `this` from Public Methods


In multi-threaded environments, returning `this` from public methods can lead to race conditions if multiple threads are accessing the same object. Instead, consider using the PIMPL (Pointer to Implementation) idiom or returning copies of the object.


## 2. Use `std::atomic` for Shared Resources


When you need to share resources between threads, use `std::atomic` to ensure atomic operations:


```c++
#include <atomic>
#include <iostream>
#include <thread>

class Counter {
  std::atomic<int> count{0};

 public:
  void increment() { ++count; }

  int get() const { return count.load(); }
};

void workerThread(Counter* counter) {
  for (int i = 0; i < 1000; ++i) {
    counter->increment();
  }
}

int main() {
  Counter counter;
  std::thread t1(workerThread, &counter);
  std::thread t2(workerThread, &counter);

  t1.join();
  t2.join();

  std::cout << "Final count: "
  << counter.get() << '\n';
  return 0;
}
```


```plain text
//<o>
Final count: 2000
```


## 3. Use Mutex for More Complex Scenarios


For more complex scenarios where atomic operations aren't sufficient, use mutex to protect shared resources:


```c++
#include <iostream>
#include <mutex>
#include <thread>

class ThreadSafeCounter {
  mutable std::mutex mutex;
  int count = 0;

 public:
  void increment() {
    std::lock_guard<std::mutex> lock(mutex);
    ++count;
  }

  int get() const {
    std::lock_guard<std::mutex> lock(mutex);
    return count;
  }

  // Using 'this' safely in a multi-threaded context
  ThreadSafeCounter* incrementAndReturn() {
    std::lock_guard<std::mutex> lock(mutex);
    ++count;
    return this;  //<h>
  }
};

void workerThread(ThreadSafeCounter* counter) {
  for (int i = 0; i < 1000; ++i) {
    counter->incrementAndReturn();
  }
}

int main() {
  ThreadSafeCounter counter;
  std::thread t1(workerThread, &counter);
  std::thread t2(workerThread, &counter);

  t1.join();
  t2.join();

  std::cout << "Final count: "
    << counter.get() << '\n';
  return 0;
}
```


```plain text
//<o>
Final count: 2000
```


## 4. Be Cautious with Singleton Pattern


If you're using the Singleton pattern in a multi-threaded environment, ensure thread-safe initialization:


```c++
#include <iostream>
#include <mutex>

class Singleton {
 private:
  static Singleton* instance;
  static std::mutex mutex;

  Singleton() = default;

 public:
  static Singleton* getInstance() {
    std::lock_guard<std::mutex> lock(mutex);
    if (instance == nullptr) {
      instance = new Singleton();
    }
    return instance;
  }

  void someOperation() {
    std::cout << "Singleton operation\n";
  }
};

Singleton* Singleton::instance = nullptr;
std::mutex Singleton::mutex;

int main() {
  Singleton::getInstance()->someOperation();
  return 0;
}
```


```plain text
//<o>
Singleton operation
```


Remember, when using `this` in a multi-threaded environment, always consider the potential for race conditions and ensure proper synchronization mechanisms are in place.


The key is to protect shared resources and ensure that operations on `this` are atomic or properly synchronized when accessed from multiple threads.

Using `this` in Multithreaded Code

The Observer pattern is a behavioral design pattern where an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes. Let's implement this pattern using the `this` pointer in C++:


```c++
#include <iostream>
#include <vector>

class Observer {
 public:
  virtual ~Observer() = default;
  virtual void update(
    const std::string& message) = 0;
};

class Subject {
 private:
  std::vector<Observer*> observers;

 public:
  virtual ~Subject() = default;

  // Using 'this' to return the current instance
  Subject* attach(Observer* observer) {
    observers.push_back(observer);
    return this;  //<h>
  }

  Subject* detach(Observer* observer) {
    observers.erase(std::remove(
      observers.begin(), observers.end(), observer
    ),  observers.end());
    return this;  //<h>
  }

  void notify(const std::string& message) {
    for (Observer* observer : observers) {
      observer->update(message);
    }
  }
};

class ConcreteObserver : public Observer {
 private:
  std::string name;

 public:
  ConcreteObserver(const std::string& name)
  : name(name) {}

  void update(const std::string& message) override {
    std::cout << name << " received message: "
      << message << '\n';
  }
};

int main() {
  Subject subject;
  ConcreteObserver observer1("Observer 1");
  ConcreteObserver observer2("Observer 2");

  subject.attach(&observer1)->attach(&observer2);  //<h>

  subject.notify("Hello, observers!");

  subject.detach(&observer1);

  subject.notify("Observer 1 has left.");
}
```


```plain text
//<o>
Observer 1 received message: Hello, observers!
Observer 2 received message: Hello, observers!
Observer 2 received message: Observer 1 has left.
```


In this implementation, we use the `this` pointer in two key places.  Firstly, in the `attach()` method of the `Subject` class:


```c++
Subject* attach(Observer* observer) {
    observers.push_back(observer);
    return this;
}
```


Secondly, in the `detach()` method of the `Subject` class:


```c++
Subject* detach(Observer* observer) {
  observers.erase(std::remove(
    observers.begin(),
    observers.end(),
    observer
  ), observers.end());

  return this;
}
```


By returning `this`, we enable method chaining, which allows for more concise and readable code when attaching or detaching multiple observers:


```c++
subject.attach(&observer1)->attach(&observer2);
```


This line attaches both `observer1` and `observer2` to the subject in a single statement.


The `this` pointer is crucial here because:

1. It allows us to return a pointer to the current instance (`Subject*`).
2. This enables method chaining, making our client code more fluent and expressive.

The Observer pattern is particularly useful in scenarios where you need a one-to-many dependency between objects. For example, when an object needs to automatically notify a list of other objects about its changes, without needing to know who these objects are.


This pattern is commonly used in implementing distributed event handling systems, in Model-View-Controller (MVC) architectural patterns, and in implementing callback functionality.

Implementing the Observer Pattern

No, it's not possible to use the `this` pointer in static member functions in C++. Let's explore why this is the case and what alternatives we have.


## Why `this` Can't Be Used in Static Functions


Static member functions belong to the class itself, not to any specific instance of the class. The `this` pointer, on the other hand, points to the instance of the class on which a member function is being called.


Since static functions don't operate on a specific instance, there's no `this` pointer available to them. Here's an example that demonstrates this:


```c++
#include <iostream>

class MyClass {
 public:
  void nonStaticFunction() {
    std::cout << "Non-static function. this: "
      << this << '\n';
  }

  static void staticFunction() {
    std::cout << "Static function. No 'this' "
      "pointer available.\n";
  }
};

int main() {
  MyClass obj;
  obj.nonStaticFunction();
  MyClass::staticFunction();
}
```


```plain text
//<o>
Non-static function. this: 0x7ffd5e8e9b1f
Static function. No 'this' pointer available.
```


If you try to use `this` in a static function, you'll get a compilation error:


```c++
#include <iostream>

class MyClass {
 public:
  static void staticFunction() {
    // Error: 'this' is unavailable for static member
    std::cout << "Static function this: " << this;  //<e>
  }
};

int main() {
  MyClass obj;
  MyClass::staticFunction();
}
```


```plain text
//<oe>
error C2355: 'this': can only be referenced inside non-static member functions or non-static data member initializers
```

Using `this` in Static Functions

<Excerpt>


Within our member functions, we have access to a specific keyword: `this`.


The `this` keyword stores a pointer to the object that our member function was called on.


For example, if we were to call `SomeObject.SomeFunction()`, within the body of `SomeFunction()`, the `this` keyword would contain a pointer to `SomeObject`.


Below, we show this in action.  We're logging out the address of `SomeObject` using the address-of operator, `&`.  


</Excerpt>


Then we're calling `SomeFunction()` on that same object, which is logging out the value of `this`:


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

struct SomeType {
  void SomeFunction(){
    cout << this;//<h>
  }
};

int main(){
  SomeType SomeObject;
  cout << &SomeObject << '\n';
  SomeObject.SomeFunction();
}
```


We can see from the output that both of the memory addresses are the same:


```c++
//<o>
000000C05694FBF4
000000C05694FBF4
```


## Dereferencing `this`


We can use `this` like any pointer.  We can store it in a variable or use it as an argument to a different function call.


We can also dereference it using the `*` operator to access the object itself.  In the following example:

- the `Pointer` function returns a pointer to the current object, using `this` and a return type of `SomeType*`
- the `Reference` function returns a reference to the current object, using `*this` and a return type of `SomeType&`
- the `Copy` function returns a copy of the current object, using `*this` and a return type of `SomeType`

```c++
struct SomeType {
  SomeType* Pointer(){ return this; }
  SomeType& Reference(){ return *this; }
  SomeType  Copy(){ return *this; }
};
```


There are many scenarios where the `this` pointer is useful.  The rest of this lesson will focus on some applications.


## Use Case 1: Identifying the Caller


Sometimes, our functions need to know who called them.


For example, let's imagine we have a `Character` class, where objects can `Attack()` each other.


When a character is attacked, they will likely want to know who attacked it, so it can react accordingly.


The `this` pointer can help us achieve that:


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

class Character {
public:
  Character(string Name) : mName{Name}{}

  void Attack(Character& Target){
    Target.TakeDamage(*this); //<h>
  }

  void TakeDamage(Character& Attacker){
    cout << Attacker.mName
      << " has attacked me!";
  }

  string mName;
};

int main(){
  Character Player{"Player One"};
  Character Monster{"Goblin"};

  Player.Attack(Monster);
}
```


```c++
//<o>
Player One has attacked me!
```


## Use Case 2: Chaining Function Calls


Another scenario where we might want to use `this` is to return the object that the method was called on.


This allows us to create APIs where member functions can be chained together.  We show an example of this below, where we have two setters, each returning a `Character&`, that is, a reference to a `Character`.


We generate these by dereferencing the `this` pointer using the `*` operator:


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

class Character {
public:
  Character& SetName(string Name){
    mName = Name;
    return *this;//<h>
  }

  Character& SetLevel(int Level){
    mLevel = Level;
    return *this;//<h>
  }

  Character& Log(){
    cout << "I am a " << mName
      << " and I am level " << mLevel;
    return *this;//<h>
  }

private:
  string mName;
  int mLevel;
};

int main(){
  Character Enemy;

  Enemy//<h>
    .SetName("Goblin Warrior")//<h>
    .SetLevel(10)//<h>
    .Log();//<h>
}
```


```c++
//<o>
I am a Goblin Warrior and I am level 10
```


## Use Case 3: Overloading Operators


A final use case for the `this` pointer that is worth highlighting is related to chaining functions.  Operators are functions too, and we sometimes want to chain them.


For example, operators such as `++` and `*=` are generally expected to be chainable.  If our custom type supports these operators, an expression like this should be possible:


```c++
(++x) *= 2;
```


The expectation here would be that `x` be incremented, and then its value doubled.  For this to work correctly, the prefix `++` operator would need to return a reference to its operand - `x` in this case.


Therefore, if we wanted to implement these operators correctly for our custom type, we need to use the `this` keyword.


The following example is overloading the _**prefix**_ form of the `++` operator, for use in expressions like `++SomeVector`.  We cover the _**postfix**_ variation (to enable `SomeVector++`) later in the lesson.


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

struct Vector3 {
  float x;
  float y;
  float z;

  Vector3& operator++(){
    ++x;
    ++y;
    ++z;
    return *this;//<h>
  }

  Vector3& operator*=(int Multiplier){
    x *= Multiplier;
    y *= Multiplier;
    z *= Multiplier;
    return *this;//<h>
  }
};

int main(){
  Vector3 SomeVector{1.0, 2.0, 3.0};

  (++SomeVector) *= 2;

  cout << "x = " << SomeVector.x
    << ", y = " << SomeVector.y
    << ", z = " << SomeVector.z;
}
```


```c++
//<o>
x = 4, y = 6, z = 8
```


<Quiz title="Overloading the `-=` Operator">


<Question>


How could we implement the `-=` operator for `Vector3` to enable expressions like this:


```c++
int main(){
  Vector3 A{1.0, 2.0, 3.0};
  Vector3 B{0.0, 0.0, 2.0};

  A -= B;
}
```


`A` should have a value of `{1.0, 2.0, 1.0}` after this operation.


<Answer>


```c++
//<qa>
struct Vector3 {
  float x;
  float y;
  float z;

  Vector3 operator-=(Vector3 Other){
    return Vector3{
      x - Other.x,
      y - Other.y,
      z - Other.z,
    };
  }
};
```


<Feedback>


This is the right idea, but this function will return a new `Vector3` rather than modifying the existing one.


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
struct Vector3 {
  float x;
  float y;
  float z;

  Vector3 operator-=(Vector3 Other){
    x -= Other.x;
    y -= Other.y;
    z -= Other.z;
    return *this;
  }
};
```


<Feedback>


Close!  This function will modify our object correctly, but it will then return a copy of the object.  This can prevent the `-=` operator from working correctly when chained with other operators.


</Feedback>


</Answer>


<Answer isCorrect>


```c++
//<qa>
struct Vector3 {
  float x;
  float y;
  float z;

  Vector3& operator-=(Vector3 Other){
    x -= Other.x;
    y -= Other.y;
    z -= Other.z;
    return *this;
  }
};
```


<Feedback>


You got it!  This will modify our object correctly, and then return a reference to the same object so additional operations can be chained correctly.


</Feedback>


</Answer>


</Question>


</Quiz>


<Aside>


### Using Free Functions


Operators like `++` and `*=` can also be implemented using free functions.  To get the equivalent behavior as we did using the `this` pointer, they need to receive the operand by reference, and return that same reference:


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

struct Vector3 {
  float x;
  float y;
  float z;
};

Vector3& operator++(Vector3& vec){ //<h>
  ++vec.x;
  ++vec.y;
  ++vec.z;
  return vec; //<h>
}

Vector3& operator*=(Vector3& vec, int mult){ //<h>
  vec.x *= mult;
  vec.y *= mult;
  vec.z *= mult;
  return vec; //<h>
}

int main(){
  Vector3 SomeVector{1.0, 2.0, 3.0};

  (++SomeVector) *= 2;

  cout << "x = " << SomeVector.x
    << ", y = " << SomeVector.y
    << ", z = " << SomeVector.z;
}
```


```c++
//<o>
x = 4, y = 6, z = 8
```


</Aside>


## Prefix and Postfix Operators


We have previously seen the increment operator `++` in action with built-in types like integers.  Earlier in the course, we mentioned that the operator can go either _**before**_ or _**after**_ the operand.


These are two different operators, but there is a subtle difference in how they're expected to work.  Let's go through an example with the built-in `int` type.


After running the following code, `MyNumber` will be `6`:


```c++
int MyNumber { 5 };
MyNumber++;
```


Specifically, this is called the _postfix increment_ operator, because the `++` appears after the operand. There is also the _prefix increment_ operator:


```c++
int MyNumber { 5 };
++MyNumber;
```


After running the above code, `MyNumber` will also be `6`, just like when we used the postfix operator.


The difference is the value that is _**returned**_ from each operator. The postfix operator will return the value of the `int` **before** it is incremented.  The prefix operator will return the value of the `int` **after** it is incremented.


This is relevant if we're immediately using the operator within an expression:


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

int main(){
  int x{5};
  cout << "x++: " << x++;
  cout << " (x is now " << x << ")\n";

  int y{5};
  cout << "++y: " << ++y;
  cout << " (y is now " << y << ")\n";
}
```


Both operands eventually have the same value, but the postfix variant `x++` returns the _**old value**_, whilst the prefix variant `++y` returned the _**new value:**_


```c++
//<o>
x++: 5 (x is now 6)
++y: 6 (y is now 6)
```


<Quiz title="Prefix and Postfix Operators">


<Question>


Consider the following code:


```c++
void MyFunction(int x){};

int main(){
  int x{1};
  MyFunction(x++);
  MyFunction(++x);
}
```


What argument is used in our calls to `MyFunction()`?


<Answer>


`1` and then `2`


<Feedback>


Remember, the prefix increment `++x` returns the value after incrementing. Consider how this affects the value passed to `MyFunction()` in the second call.


</Feedback>


</Answer>


<Answer isCorrect>


`1` and then `3`


<Feedback>


You got it! The first call uses the original value of `x`, and the second reflects the incremented value after both operations.


</Feedback>


</Answer>


<Answer>


`2` and then `3`


<Feedback>


Consider the difference in how prefix and postfix increment operators work. The prefix `++x` increments before returning the value, whereas `x++` increments after.


</Feedback>


</Answer>


</Question>


</Quiz>


## Overloading Postfix Operators


As we've seen above, we can overload the prefix operators in the same way we overload any other operator.


To overload a postfix operator, the syntax is a little inelegant.  We need to specify an additional, unused `int` parameter in our function prototype.  We typically don't give this extra parameter a name.


So, to overload the postfix `++` operator as a free function, it would look like this:


```c++
Vector3 operator++(Vector3 Vec, int){//<h>
  // ...
}
```


Using a member function, it looks like this:


```c++
struct Vector3 {
  Vector3 operator++(int){//<h>
    // ...
  }
};
```


The expected behavior of the postfix `++` operator is to increment the operand, but to return an object that had the original value, before the increment was applied.


To do this, we typically have three steps:

1. Create a copy of the object with its current value
2. Modify the object to increment it
3. Return the original copy

It looks like this:


```c++
struct Vector3 {
  float x;
  float y;
  float z;

  Vector3 operator++(int){
    Vector3 temp{*this};
    ++x;
    ++y;
    ++z;
    return temp;
  }
};
```


Typically when we're implementing the postfix operator, we've also implemented the prefix operator.


So our postfix operator can make use of it, allowing our code to be simplified to something like this:


```c++
struct Vector3 {
  float x;
  float y;
  float z;

  // Prefix operator
  Vector3& operator++(){
    ++x;
    ++y;
    ++z;
    return *this;
  }

  // Postfix operator
  Vector3 operator++(int){
    Vector3 temp{*this};
    ++(*this);//<h>
    return temp;
  }
};
```


<Quiz title="Implementing the Postfix `--` Operator">


How can we add the postfix `--` operator to the following class?  Note that the prefix `--` is already available:


```c++
struct Vector3 {
  float x;
  float y;
  float z;

  // Prefix -- operator
  Vector3& operator--(){
    --x;
    --y;
    --z;
    return *this;
  }

  // Postfix -- operator
  // ???
};
```


<Question>


<Answer>


```c++
//<qa>
Vector3 operator--(){
  Vector3 temp{*this};
  (*this)--;
  return temp;
}
```


<Feedback>


This is implementing the prefix operator.  Remember, the postfix operator has an additional parameter.


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
Vector3 operator--(int){
  Vector3 temp{*this};
  (*this)--;
  return temp;
}
```


<Feedback>


This is the correct prototype for the postfix `--` operator.  However, the operator is calling itself, effectively creating an infinite loop.


</Feedback>


</Answer>


<Answer isCorrect>


```c++
//<qa>
Vector3 operator--(int){
  Vector3 temp{*this};
  --(*this);
  return temp;
}
```


<Feedback>


You got it!


</Feedback>


</Answer>


<Answer>


```c++
//<qa>
Vector3 operator--(int){
  --(*this);
  return *this;
}
```


<Feedback>


This is correctly modifying the operand, but it is returning a copy of the operand with its modified values.


This is not how the postfix `--` operator is expected to behave.


</Feedback>


</Answer>


</Question>


</Quiz>


<Aside>


### Postfix vs Prefix Operator Performance


As the previous example perhaps demonstrates, the postfix increment and decrement operators need to do slightly more work than their prefix counterparts.


Copying our object to support the expected postfix behavior has a performance overhead.  Therefore, `++SomeObject` is generally faster than `SomeObject++`


Because of this, when we're calling these operators, if we don't care about the return value of the expression, we should default to using the prefix variations. 


In other words, prefer `++SomeObject` unless we have a specific reason to use `SomeObject++`.


</Aside>


## Summary


In this lesson, we explored the `this` pointer, a fundamental concept for understanding object-oriented programming in this language.


We began by explaining what the `this` pointer is - a special pointer that points to the object for which a member function is called. We then delved into various practical applications:

1. Dereferencing `this`: We discussed how `this` can be dereferenced to access the object itself and how it can be used to access a pointer, a reference, or a copy of the object.
2. Identifying the Caller: We examined a use case where `this` helps in identifying which object called a member function, allowing our objects to interact with each other in more complex ways.
3. Chaining Function Calls: We showed how `this` can be used to return the current object, enabling the chaining of member function calls for more fluent and readable code.
4. Overloading Operators: We also covered how `this` plays a crucial role in overloading operators like `++` and `*=` to ensure our custom types are consistent with built-in types.

<Preview>


### Dangling Pointers and References


In the next lesson, we introduce dangling pointers and references.  We'll better understand the lifespan of local variables and the risks associated with returning pointers or references to them.


</Preview>

3D art showing a fantasy pirate character

The this pointer

The keyword this

{CPP}Explore the fundamentals of the "this" pointer in C++. Perfect for beginners

The `this` Pointer

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers

The this Pointer

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Questions & Answers

The `this` Pointer