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

Swapping values using pointers without a temporary variable is an interesting technique, but it's important to note that it's not always the most readable or maintainable approach. However, it can be useful in certain situations where performance is critical. Here's how you can do it:


```c++
#include <iostream>

void swap(int* a, int* b) {
  // Check if the pointers are not the same
  if (a != b) {
    // XOR the values
    *a = *a ^ *b;
    // XOR again to get the original value of a
    *b = *a ^ *b;
    // XOR one more time to get the
    // original value of b
    *a = *a ^ *b;
  }
}

int main() {
  int x{5};
  int y{10};

  std::cout << "Before swap: x = "
    << x << ", y = " << y << "\n";

  swap(&x, &y);

  std::cout << "After swap: x = "
    << x << ", y = " << y << "\n";
}
```


```plain text
//<o>
Before swap: x = 5, y = 10
After swap: x = 10, y = 5
```


This technique uses the XOR operation to swap the values. Here's how it works:

1. `a = *a ^ *b`: This XORs the values of `a` and `b` and stores the result in `a`.
2. `b = *a ^ *b`: This XORs the new value of `a` with `b`, which gives us the original value of `a`, stored in `b`.
3. `a = *a ^ *b`: This XORs the value in `a` with the new value in `b`, giving us the original value of `b`, now stored in `a`.

While this method is clever, it's worth noting that modern compilers are very good at optimizing standard swap operations. In most cases, using a temporary variable or `std::swap()` will be just as efficient and much more readable:


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

int main() {
  int x{5};
  int y{10};

  std::cout << "Before swap: x = "
    << x << ", y = " << y << "\n";

  std::swap(x, y);

  std::cout << "After swap: x = "
    << x << ", y = " << y << "\n";
}
```


Remember, code readability is often more important than micro-optimizations. Use the pointer-based swap only when you have a specific reason to do so and when you're sure it provides a significant performance benefit in your specific use case.

Swapping Values with Pointers

Memory leaks can be a significant issue when working with pointers in C++. They occur when dynamically allocated memory is not properly deallocated, leading to wasted resources and potential program crashes. Here are some best practices to avoid memory leaks:


## Use Smart Pointers


The most effective way to prevent memory leaks is to use smart pointers from the `<memory>` header. These automatically manage memory deallocation:


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

class Character {
 public:
  Character(std::string name)
  : mName{std::move(name)} {}
  std::string mName;
};

int main() {
  // Using unique_ptr for exclusive ownership
  std::unique_ptr<Character> player{
    std::make_unique<Character>("Anna")};
  std::cout << "Player name: "
    << player->mName << "\n";

  // Using shared_ptr for shared ownership
  std::shared_ptr<Character> enemy{
    std::make_shared<Character>("Goblin")};
  std::cout << "Enemy name: "
    << enemy->mName << "\n";
}
```


`std::unique_ptr` and `std::shared_ptr` automatically delete the object they own when they go out of scope, preventing memory leaks.


## RAII (Resource Acquisition Is Initialization)


Follow the RAII principle: wrap resource management in classes whose constructors acquire the resource and destructors release it.


## Avoid Raw `new` and `delete`


Minimize the use of raw `new` and `delete`. If you must use them, ensure every `new` is matched with exactly one `delete`:


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

class Weapon {
 public:
  Weapon(std::string name)
  : mName{std::move(name)} {}
  ~Weapon() {
    std::cout << mName << " destroyed\n";
  }
  std::string mName;
};

void badPractice() {
  Weapon* sword = new Weapon("Excalibur");
  // ... some code ...
  // Oops! We forgot to delete sword. Memory leak!
}

void goodPractice() {
  Weapon* sword = new Weapon("Excalibur");
  // ... some code ...
  delete sword;  // Remember to delete!
}

int main() {
  badPractice();
  goodPractice();
}
```


```c++
//<o>
Excalibur destroyed
```


## Use `std::vector` Instead of Raw Arrays


Prefer `std::vector` over raw arrays when you need a dynamic collection:


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

int main() {
  std::vector<int> scores{10, 20, 30};
  scores.push_back(40);
  for (int score : scores) {
    std::cout << score << " ";
  }
}
```


## Be Careful with Circular References


Circular references can cause memory leaks with `std::shared_ptr`. Use `std::weak_ptr` to break cycles:


```c++
#include <memory>

class Character;

class Weapon {
 public:
  // Use weak_ptr to avoid circular reference
  std::weak_ptr<Character> mOwner;
};

class Character {
 public:
  std::shared_ptr<Weapon> mWeapon;
};

int main() {
  auto character = std::make_shared<Character>();
  character->mWeapon = std::make_shared<Weapon>();
  character->mWeapon->mOwner = character;
}
```


By following these practices, you can significantly reduce the risk of memory leaks in your C++ programs.

Preventing Memory Leaks with Pointers

Smart pointers and raw pointers are both tools for managing memory in C++, but they have some key differences in terms of functionality and usage. Let's break down each type and discuss when to use them.


## Raw Pointers


Raw pointers are the traditional C-style pointers. They're simple and lightweight, but they require manual memory management.


```c++
#include <iostream>

class Weapon {
 public:
  Weapon(std::string name)
  : mName{std::move(name)} {}
  ~Weapon() {
    std::cout << mName << " destroyed\n";
  }
  std::string mName;
};

int main() {
  Weapon* sword = new Weapon("Excalibur");
  // Use sword...
  delete sword;  // Remember to delete!
}
```


Raw pointers don't automatically free memory when they go out of scope, which can lead to memory leaks if not managed carefully.


## Smart Pointers


Smart pointers, introduced in C++11, are objects that act like pointers but provide additional features, most notably automatic memory management. The two main types are `std::unique_ptr` and `std::shared_ptr`.


### `std::unique_ptr`


`std::unique_ptr` is for exclusive ownership. Only one `unique_ptr` can own an object at a time.


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

class Weapon {
 public:
  Weapon(std::string name)
  : mName{std::move(name)} {}
  ~Weapon() {
    std::cout << mName << " destroyed\n";
  }
  std::string mName;
};

int main() {
  std::unique_ptr<Weapon> sword{
    std::make_unique<Weapon>("Excalibur")};
  // Use sword...
}  // sword is automatically deleted here
```


```c++
//<o>
Excalibur destroyed
```


### `std::shared_ptr`


`std::shared_ptr` allows multiple pointers to share ownership of an object. The object is deleted when the last `shared_ptr` is destroyed.


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

class Character {
 public:
  Character(std::string name)
  : mName{std::move(name)} {}
  ~Character() {
    std::cout << mName << " destroyed\n";
  }
  std::string mName;
};

int main() {
  std::shared_ptr<Character> hero1{
    std::make_shared<Character>("Anna")};
  {
    // Shared ownership
    std::shared_ptr<Character> hero2 = hero1;
    std::cout << "Heroes: " << hero1->mName
      << " and " << hero2->mName << "\n";

    // hero2 goes out of scope, but object
    // isn't deleted yet
  }

  std::cout << "Hero 1 still alive\n";
}
// hero1 goes out of scope, Character
// object is deleted
```


```c++
//<o>
Heroes: Anna and Anna
Hero 1 still alive
Anna destroyed
```


## When to Use Each


Use raw pointers when:

- You're working with legacy code or APIs that require raw pointers
- You need to pass a non-owning pointer (consider `std::weak_ptr` for `shared_ptr` objects)
- You're implementing low-level data structures or when performance is absolutely critical

Use smart pointers when:

- You want automatic memory management to prevent leaks
- You're designing new code and have control over the ownership model
- You need shared ownership (`std::shared_ptr`) or exclusive ownership (`std::unique_ptr`)

In modern C++, it's generally recommended to prefer smart pointers over raw pointers for most scenarios. They provide safety and convenience without significant performance overhead. However, understanding raw pointers is still crucial for working with existing codebases and certain low-level operations.

Smart Pointers vs Raw Pointers

When it comes to performance, the difference between pointers and references in C++ is often negligible in most scenarios. However, there are some subtle differences and situations where one might be preferred over the other. Let's break this down:


## Under the Hood


At the assembly level, pointers and references are often implemented similarly. A reference is typically implemented as a constant pointer that is automatically dereferenced when used. This means that in many cases, the performance difference is minimal or non-existent.


## Pass-by-Reference vs Pass-by-Pointer


Both can be used to avoid copying large objects when passing them to functions:


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

struct LargeObject {
  int data[10000];
};

void modifyByPointer(LargeObject* obj) {
  obj->data[0] = 42;
}

void modifyByReference(LargeObject& obj) {
  obj.data[0] = 42;
}

int main() {
  using namespace std::chrono;
  LargeObject obj;

  auto start = high_resolution_clock::now();
  for (int i = 0; i < 1000000; ++i) {
    modifyByPointer(&obj);
  }
  auto end = high_resolution_clock::now();
  std::cout << "Pointer time: "
    << std::chrono::duration_cast<microseconds>(
      end - start).count()
    << " microseconds\n";

  start = high_resolution_clock::now();
  for (int i = 0; i < 1000000; ++i) {
    modifyByReference(obj);
  }
  end = high_resolution_clock::now();
  std::cout << "Reference time: "
    << std::chrono::duration_cast<microseconds>(
      end - start).count()
    << " microseconds\n";
}
```


In this example, you'll likely find that the performance difference is negligible.


## Null Checking


Pointers allow for null checking, which can introduce a small performance overhead:


```c++
// This check introduces a small overhead
void processCharacter(Character* character) {
  if (character) {
    character->doSomething();
  }
}

// No null check possible
void processCharacter(Character& character) {
  character.doSomething();
}
```


References, on the other hand, are assumed to always be valid, which can lead to slightly better performance in scenarios where null checks aren't necessary.


## Polymorphism


Both pointers and references support polymorphism, allowing for runtime polymorphic behavior:


```c++
#include <iostream>

class Weapon {
 public:
  virtual void attack() = 0;
};

class Sword : public Weapon {
 public:
  void attack() override {
    std::cout << "Sword attack!\n";
  }
};

void useWeapon(Weapon* weapon) {
  weapon->attack();
}

void useWeapon(Weapon& weapon) {
  weapon.attack();
}

int main() {
  Sword sword;
  useWeapon(&sword);  // Using pointer
  useWeapon(sword);   // Using reference
}
```


```c++
//<o>
Sword attack!
Sword attack!
```


The performance difference here is typically negligible.


## Conclusion


In most cases, the performance difference between pointers and references is minimal. The choice between them should generally be based on semantics rather than performance:

- Use references when you have an object that must exist and cannot be null.
- Use pointers when you need to represent the absence of an object (null) or when you need to change what the pointer points to.

Modern compilers are very good at optimizing code, often eliminating any performance differences between pointers and references. Focus on writing clear, maintainable code, and choose between pointers and references based on your specific needs and the semantics of your program.

Performance: Pointers vs References

Working with pointers in multithreaded applications can be tricky and introduce various issues if not handled carefully. Here are some common pitfalls and how to avoid them:


## Race Conditions


Race conditions occur when multiple threads access shared data concurrently, and at least one thread modifies the data.


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

class SharedResource {
 public:
  int* data{nullptr};
};

void modifyData(SharedResource* resource) {
  if (resource->data == nullptr) {
    resource->data = new int(42);  //<w>
  }
  (*resource->data)++;  //<w>
}

int main() {
  SharedResource resource;
  std::vector<std::thread> threads;

  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(modifyData, &resource);
  }

  for (auto& t : threads) {
    t.join();
  }

  std::cout << "Final value: "
    << *resource.data << "\n";
  delete resource.data;
}
```


```c++
//<o>
Final value: 51
```


This code has multiple issues:

- Multiple threads might try to initialize `data` simultaneously.
- Incrementing `resource->data` is not atomic and can lead to lost updates.

To fix this, use proper synchronization mechanisms like mutexes:


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

class SharedResource {
 public:
  int* data{nullptr};
  std::mutex mutex;
};

void modifyData(SharedResource* resource) {
  std::lock_guard<std::mutex> lock(
    resource->mutex
  );
  if (resource->data == nullptr) {
    resource->data = new int(42);
  }
  (*resource->data)++;
}

int main() {
  SharedResource resource;
  std::vector<std::thread> threads;

  for (int i = 0; i < 10; ++i) {
    threads.emplace_back(modifyData, &resource);
  }

  for (auto& t : threads) {
    t.join();
  }

  std::cout << "Final value: "
    << *resource.data << "\n";
  delete resource.data;
}
```


```c++
//<o>
Final value: 52
```


## Dangling Pointers


Dangling pointers occur when a pointer refers to memory that has been deallocated. This is particularly dangerous in multithreaded contexts:


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

class Resource {
 public:
  int value{42};
};

Resource* globalResource = nullptr;

void createResource() {
  globalResource = new Resource();
}

void useResource() {
  std::this_thread::sleep_for(
    std::chrono::milliseconds(10));
  if (globalResource) {
    std::cout << globalResource->value << "\n";  //<w>
  }
}

void deleteResource() {
  delete globalResource;
  globalResource = nullptr;
}

int main() {
  std::thread t1(createResource);
  std::thread t2(useResource);
  std::thread t3(deleteResource);

  t1.join();
  t2.join();
  t3.join();
}
```


```c++
//<o>
42
```


This code might crash if `deleteResource` runs before `useResource`. To fix this, use proper synchronization and consider using smart pointers:


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

class Resource {
 public:
  int value{42};
};

std::shared_ptr<Resource> globalResource;
std::mutex resourceMutex;

void createResource() {
  std::lock_guard<std::mutex> lock(resourceMutex);
  globalResource = std::make_shared<Resource>();
}

void useResource() {
  std::this_thread::sleep_for(
    std::chrono::milliseconds(10));
  std::lock_guard<std::mutex> lock(resourceMutex);
  if (globalResource) {
    std::cout << globalResource->value << "\n";
  }
}

void deleteResource() {
  std::lock_guard<std::mutex> lock(resourceMutex);
  globalResource.reset();
}

int main() {
  std::thread t1(createResource);
  std::thread t2(useResource);
  std::thread t3(deleteResource);

  t1.join();
  t2.join();
  t3.join();
}
```


## Memory Leaks


Memory leaks can occur if a thread responsible for freeing memory terminates unexpectedly:


```c++
#include <chrono>
#include <thread>

void leakyFunction() {
  int* data = new int[1000];
  std::this_thread::sleep_for(
    std::chrono::seconds(1));
  // Thread might be terminated before
  // reaching this point
  delete[] data;  //<w>
}

int main() {
  std::thread t(leakyFunction);
  std::this_thread::sleep_for(
    std::chrono::milliseconds(500));

  // Detaching the thread,
  // potentially causing a leak
  t.detach();
}
```


To prevent this, use RAII (Resource Acquisition Is Initialization) principles and smart pointers:


```c++
#include <chrono>
#include <memory>
#include <thread>

void safeFunction() {
  auto data = std::make_unique<int[]>(1000);
  std::this_thread::sleep_for(
    std::chrono::seconds(1));
  // Memory will be automatically freed when
  // the unique_ptr goes out of scope
}

int main() {
  std::thread t(safeFunction);
  std::this_thread::sleep_for(
    std::chrono::milliseconds(500));
  t.detach();
}
```


## Conclusion


When working with pointers in multithreaded applications:

- Use proper synchronization mechanisms (mutexes, atomic operations).
- Prefer smart pointers over raw pointers.
- Use RAII to manage resource lifetimes.
- Be cautious with global or shared pointers.
- Consider using thread-safe data structures from the standard library.

Remember, multithreading adds complexity to pointer management. Always design your multithreaded code carefully and consider thread safety at every step.

Pointers in Multithreaded Code

Managing pointer ownership in complex object hierarchies can be challenging, but there are several strategies you can employ to make it more manageable and less error-prone. Let's explore some of these strategies:


## Use Smart Pointers


Smart pointers are the cornerstone of modern C++ memory management. They help clarify ownership semantics and prevent memory leaks.


### `std::unique_ptr` for Exclusive Ownership


Use `std::unique_ptr` when an object should have only one owner:


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

class Weapon {
 public:
  Weapon(std::string name)
  : mName{std::move(name)} {}
  std::string mName;
};

class Character {
 public:
  Character(std::string name)
  : mName{std::move(name)} {}
  void equip(std::unique_ptr<Weapon> weapon) {
    mWeapon = std::move(weapon);
  }
  std::string mName;
  std::unique_ptr<Weapon> mWeapon;
};

int main() {
  auto character = std::make_unique<Character>(
    "Hero");
  character->equip(std::make_unique<Weapon>(
    "Sword"));
  std::cout << character->mName
    << " equipped "
    << character->mWeapon->mName  << "\n";
}
```


```c++
//<o>
Hero equipped Sword
```


### `std::shared_ptr` for Shared Ownership


Use `std::shared_ptr` when multiple objects might own a resource:


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

class Item {
 public:
  Item(std::string name)
  : mName{std::move(name)} {}
  std::string mName;
};

class Inventory {
 public:
  void addItem(std::shared_ptr<Item> item) {
    mItems.push_back(item);
  }
  std::vector<std::shared_ptr<Item>> mItems;
};

class Character {
 public:
  Character(std::string name)
  : mName{std::move(name)} {}
  Inventory mInventory;
  std::string mName;
};

int main() {
  auto hero = std::make_unique<Character>(
    "Hero");
  auto companion = std::make_unique<Character>(
    "Companion");

  auto sharedItem = std::make_shared<Item>(
    "Magic Potion");
  hero->mInventory.addItem(sharedItem);
  companion->mInventory.addItem(sharedItem);

  std::cout << "Item count: "
    << sharedItem.use_count() << "\n";
}
```


```c++
//<o>
Item count: 3
```


## Implement Clear Ownership Policies


Establish clear rules about who owns what in your object hierarchy:


```c++
class Game {
 public:
  void addCharacter(
    std::unique_ptr<Character> character
  ) {
    mCharacters.push_back(std::move(character));
  }
  std::vector<std::unique_ptr<
    Character>> mCharacters;
};

int main() {
  Game game;
  game.addCharacter(std::make_unique<Character>(
    "Hero"));
  game.addCharacter(std::make_unique<Character>(
    "Villain"));
}
```


In this example, `Game` clearly owns all `Character` objects.


## Use Weak Pointers to Break Circular References


`std::weak_ptr` can be used to break circular references that might occur with `std::shared_ptr`:


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

class Character;

class Weapon {
 public:
  Weapon(std::string name)
  : mName{std::move(name)} {}
  void setOwner(std::shared_ptr<Character> owner) {
    mOwner = owner;
  }
  std::weak_ptr<Character> mOwner;
  std::string mName;
};

class Character {
 public:
  Character(std::string name)
  : mName{std::move(name)} {}
  void equip(std::shared_ptr<Weapon> weapon) {
    mWeapon = weapon;
    weapon->setOwner(shared_from_this());
  }
  std::shared_ptr<Weapon> mWeapon;
  std::string mName;
};

int main() {
  auto character = std::make_shared<Character>(
    "Hero");
  auto weapon = std::make_shared<Weapon>(
    "Sword");
  character->equip(weapon);

  std::cout << "Character use count: "
    << character.use_count() << "\n";
  std::cout << "Weapon use count: "
    << weapon.use_count() << "\n";
}
```


## Consider Using the PIMPL Idiom


The PIMPL (Pointer to Implementation) idiom can help manage complex hierarchies by hiding implementation details:


```c++
// Character.h
class Character {
 public:
  Character(std::string name);
  ~Character();
  Character(Character&&) noexcept;
  Character& operator=(Character&&) noexcept;
  void equip(std::string weaponName);

 private:
  class Impl;
  std::unique_ptr<Impl> pImpl;
};

// Character.cpp
#include <vector>

#include "Character.h"

class Character::Impl {
 public:
  std::string name;
  std::vector<std::unique_ptr<Weapon>> weapons;
};

Character::Character(std::string name)
: pImpl{std::make_unique<Impl>()} {
  pImpl->name = std::move(name);
}

Character::~Character() = default;
Character::Character(
  Character&&) noexcept = default;
Character& Character::operator=(
  Character&&) noexcept = default;

void Character::equip(std::string weaponName) {
  pImpl->weapons.push_back(
    std::make_unique<Weapon>(std::move(weaponName)
  ));
}
```


## Use Factory Functions


Factory functions can help enforce ownership policies:


```c++
class GameWorld {
 public:
  Character* createCharacter(std::string name) {
    auto character = std::make_unique<Character>(
      std::move(name));
    Character* rawPtr = character.get();
    mCharacters.push_back(std::move(character));
    return rawPtr;
  }

 private:
  std::vector<
    std::unique_ptr<Character>> mCharacters;
};

int main() {
  GameWorld world;
  Character* hero = world.createCharacter("Hero");
  // World owns the Character, but we can
  // still use the raw pointer
}
```


By using these strategies, you can create clear ownership semantics in your complex object hierarchies, reducing the risk of memory leaks and making your code more maintainable.


Remember, the key is to be consistent in your approach and to document your ownership policies clearly for other developers who might work with your code.

Pointer Ownership in Complex Hierarchies

Merged and rewrote "Pointers" and "The Arrow Operator" lessons

Added caveat about user-defined types to uninitialized variables section

3D art showing a female blacksmith character

Pointer (computer programming)

C++ Language Reference - Pointers

What are the differences between a pointer variable and a reference variable?

{CPP}Dive into the world of C++ pointers covering addressing, dereferencing and pointer safety

{CPP}Mastering C++: Pointers Explained for Beginners

Why Use References if Pointers are More Powerful?

Null Pointers and Uninitialized Variables

Pointers

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers