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 performance overhead of using `std::unique_ptr` compared to raw pointers in C++ is generally minimal, but it's worth understanding the differences.


## Memory Overhead


In terms of memory usage, a `std::unique_ptr` typically has the same size as a raw pointer on most implementations when using the default deleter. Let's check this:


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

int main() {
  std::cout << "Size of raw pointer: " << sizeof(int*)
      << " bytes\n";
  std::cout << "Size of unique_ptr: "
      << sizeof(std::unique_ptr<int>) << " bytes\n";
}
```


```plain text
//<o>
Size of raw pointer: 8 bytes
Size of unique_ptr: 8 bytes
```


However, if you use a custom deleter, the size may increase:


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

int main() {
  auto customDeleter = [](int* p) { delete p; };
  std::cout
    << "Size of unique_ptr with custom deleter: "
    << sizeof(
      std::unique_ptr<int, decltype(customDeleter)>
    ) << " bytes";
}
```


```plain text
//<o>
Size of unique_ptr with custom deleter: 16 bytes
```


## Runtime Performance


In terms of runtime performance:

1. Dereferencing: Dereferencing a `std::unique_ptr` is typically as fast as dereferencing a raw pointer. Modern compilers can often optimize away any overhead.
2. Creation and Destruction: Creating a `std::unique_ptr` using `std::make_unique()` is generally as fast as using `new`. Destruction is also typically as fast as using `delete`.
3. Move Operations: Moving a `std::unique_ptr` is very fast, usually just involving pointer assignment.

Here's a simple benchmark to illustrate:


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

const int ITERATIONS = 10000000;

void benchmarkRawPointer() {
  using namespace std::chrono;
  auto start = high_resolution_clock::now();
  for (int i = 0; i < ITERATIONS; ++i) {
    int* p = new int(i);
    *p += 1;
    delete p;
  }
  auto end = high_resolution_clock::now();
  duration<double> diff = end - start;
  std::cout << "Raw pointer time: " << diff.count()
      << " s\n";
}

void benchmarkUniquePtr() {
  using namespace std::chrono;
  auto start = high_resolution_clock::now();
  for (int i = 0; i < ITERATIONS; ++i) {
    auto p = std::make_unique<int>(i);
    *p += 1;
  }
  auto end = high_resolution_clock::now();
  duration<double> diff = end - start;
  std::cout << "Unique pointer time: " << diff.count()
      << " s\n";
}

int main() {
  benchmarkRawPointer();
  benchmarkUniquePtr();
}
```


```plain text
//<o>
Raw pointer time: 1.94922 s
Unique pointer time: 2.23576 s
```


The results will vary depending on your system, but they're often very close.


In practice, the small performance overhead of `std::unique_ptr` is usually outweighed by the benefits of automatic resource management and exception safety. `std::unique_ptr` helps prevent resource leaks and makes your code safer and easier to reason about, which can lead to better overall performance in complex systems.


Remember, premature optimization is the root of all evil. Always measure before optimizing, and consider the trade-offs between slight performance gains and code safety/maintainability.

Performance of Unique Pointers

Yes, it's absolutely possible to create a `std::unique_ptr` to a const object in C++. This can be useful when you want to ensure that the object pointed to by the unique pointer cannot be modified through that pointer, while still maintaining the benefits of automatic memory management provided by `std::unique_ptr`.


Here's how you can create a unique pointer to a const object:


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

int main() {
  auto constPtr = std::make_unique<const int>(42);  //<h>

  std::cout << "Value: " << *constPtr;

  // This would cause a compilation error:
  // *constPtr = 10; //<e>
}
```


```plain text
//<o>
Value: 42
```


In this example, `constPtr` is a `std::unique_ptr<const int>`, pointing to a const int. We can read the value, but we can't modify it through this pointer.


You can also create a const unique pointer to a non-const object:


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

int main() {
  const auto ptr = std::make_unique<int>(42); //<h>

  std::cout << "Value: " << *ptr << '\n';

  // This would cause a compilation error:
  // ptr = std::make_unique<int>(10); //<e>

  // But this is allowed:
  *ptr = 10;

  std::cout << "New value: " << *ptr << '\n';
}
```


```plain text
//<o>
Value: 42
New value: 10
```


Here, `ptr` is const (can't be reassigned), but the int it points to isn't const (can be modified).


You can even have a const unique pointer to a const object:


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

int main() {
  const auto constPtr =
      std::make_unique<const int>(42);  //<h>

  std::cout << "Value: " << *constPtr;

  // These would cause compilation errors:
  // constPtr =  std::make_unique<const int>(10); //<e>
  // *constPtr = 10; //<e>
}
```


```plain text
//<o>
Value: 42
```


In this case, neither the pointer nor the pointed-to object can be modified.


Remember, const-correctness is a powerful tool in C++ for preventing unintended modifications and communicating intent in your code. Using const with unique pointers allows you to leverage both the safety of const and the automatic memory management of smart pointers.


When working with classes, const unique pointers are particularly useful:


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

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

  std::string getName() const { return name; }

  void rename(const std::string& newName) {
    name = newName;
  }

private:
  std::string name;
};

int main() {
  auto constCharPtr =
    std::make_unique<const Character>("Frodo");

  std::cout << "Name: " << constCharPtr->getName();

  // This would cause a compilation error:
  // constCharPtr->rename("Gandalf"); //<e>
}
```


```plain text
//<o>
Name: Frodo
```


In this example, `constCharPtr` is a unique pointer to a const `Character`. We can call const member functions like `getName()`, but we can't call non-const member functions like `rename()`.

Unique Pointers to Const Objects

Deleting a raw pointer obtained from the `get()` method of a `std::unique_ptr` is a dangerous operation that leads to undefined behavior. It's important to understand why this is problematic and how to avoid such situations.


Let's break this down with an example:


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

class Character {
public:
  Character(std::string name)
    : name(std::move(name)) {
    std::cout << "Creating " << name << '\n';
  }

  ~Character() {
    std::cout << "Destroying " << name << '\n';
  }

private:
  std::string name;
};

int main() {
  auto frodo = std::make_unique<Character>("Frodo");

  Character* rawPtr = frodo.get(); //<h>
  delete rawPtr;                   //<e>

  // frodo still thinks it owns the object!
}
```


If we were to run this code, here's what would happen:

1. The `Character` object "Frodo" is created and owned by the `std::unique_ptr`.
2. We get the raw pointer using `get()`.
3. We delete the raw pointer, which destroys the `Character` object.
4. At the end of `main()`, `frodo` (the `std::unique_ptr`) goes out of scope and tries to delete the object again.

This results in a double deletion, which is undefined behavior. It could crash your program, corrupt memory, or seemingly do nothing while causing subtle bugs elsewhere.


Here's why this is dangerous:

1. **Ownership Violation**: `std::unique_ptr` is designed to have exclusive ownership of the object it points to. By deleting the raw pointer, we're violating this contract.
2. **Double Deletion**: The `std::unique_ptr` will try to delete the object again when it goes out of scope, leading to undefined behavior.
3. **Dangling Pointer**: After deleting the raw pointer, the `std::unique_ptr` becomes a dangling pointer, pointing to memory that has been freed.

To avoid these issues:

1. Never delete raw pointers obtained from `get()`.
2. Use `get()` only when you need to pass the raw pointer to functions that expect a raw pointer, and ensure those functions don't delete the pointer.
3. If you need to transfer ownership, use `std::move()` instead:

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

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

  ~Character() {
    std::cout << "Destroying " << mName << '\n';
  }

private:
  std::string mName;
};

void takeOwnership(std::unique_ptr<Character> ptr) {
  // This function now owns the Character object
  std::cout << "Taking ownership\n";
}

int main() {
  auto FrodoPtr = std::make_unique<Character>("Frodo");
  takeOwnership(std::move(FrodoPtr)); //<h>

  if (!FrodoPtr) {
    std::cout << "FrodoPtr is now null";
  }
}
```


```plain text
//<o>
Creating Frodo
Taking ownership
Destroying Frodo
FrodoPtr is now null
```


In this safe version, we transfer ownership of the `Character` object to the `takeOwnership` function using `std::move()`. The `std::unique_ptr` in `main()` becomes null after the move, preventing any double deletion issues.


Remember, the whole point of `std::unique_ptr` is to manage the lifetime of dynamically allocated objects automatically. By manually deleting the raw pointer, we're defeating this purpose and introducing potential bugs. Stick to using the `std::unique_ptr` interface, and let it handle the deletion for you.

Deleting Raw Pointers from Unique Pointers

Using `std::unique_ptr` in multithreaded applications is generally safe, but with some important caveats. Let's break this down:


## Thread Safety of the Pointer Itself


The `std::unique_ptr` itself is not thread-safe. This means that if you have multiple threads trying to modify the same `unique_ptr` (e.g., resetting it, moving it, or destroying it), you need to provide your own synchronization mechanisms, such as mutexes.


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

std::unique_ptr<Character> GlobalCharacter;
std::mutex CharacterMutex;

void UpdateCharacter() {
  std::lock_guard<std::mutex> Lock{CharacterMutex};
  GlobalCharacter = std::make_unique<Character>("Aragorn");
}
```


## Thread Safety of the Pointed-to Object


The thread safety of the object that the `unique_ptr` points to depends on the object itself, not on the `unique_ptr`. If multiple threads are accessing the pointed-to object concurrently, you need to ensure that the object itself is thread-safe or provide appropriate synchronization.


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

class ThreadSafeCharacter {
  mutable std::mutex Mtx;
  std::string Name;

public:
  void SetName(const std::string& NewName) {
    std::lock_guard<std::mutex> Lock{Mtx};
    Name = NewName;
  }
};

std::unique_ptr<ThreadSafeCharacter> GlobalCharacter;
```


## Unique Ownership and Threading


The unique ownership model of `std::unique_ptr` can actually be beneficial in multithreaded scenarios. Since only one `unique_ptr` can own an object at a time, it can help prevent issues like multiple threads trying to delete the same object.


However, be cautious when transferring ownership between threads:


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

void ProcessCharacter(std::unique_ptr<Character> Char) {
  // Process the character
}

int main() {
  auto Frodo{std::make_unique<Character>("Frodo")};
  std::thread T{ProcessCharacter, std::move(Frodo)}; //<h>
  T.join();
  // After this, Frodo is nullptr
}
```


In conclusion, while `std::unique_ptr` itself isn't inherently thread-safe, its unique ownership model can be valuable in multithreaded applications. Just remember to handle synchronization for the pointer itself and the pointed-to object when necessary.

Thread Safety of Unique Pointers

The `reset()` and `release()` functions are both members of `std::unique_ptr`, but they serve different purposes in managing the ownership of the pointed-to object. Let's dive into each one:


## The `reset()` Function


The `reset()` function does two things:

1. It deletes the currently owned object (if any).
2. It takes ownership of a new object (if provided).

Here's an example:


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

class Character {
public:
  std::string Name;
};

int main() {
  auto Frodo{std::make_unique<Character>("Frodo")};
  std::cout << "Before reset: " << Frodo->Name << '\n';

  Frodo.reset(new Character("Samwise")); //<h>
  std::cout << "After reset: " << Frodo->Name << '\n';

  Frodo.reset(); //<h>
  std::cout << "After reset to nullptr: "
      << (Frodo ? Frodo->Name : "nullptr") << '\n';
}
```


```plain text
//<o>
Before reset: Frodo
After reset: Samwise
After reset to nullptr: nullptr
```


## The `release()` Function


The `release()` function, on the other hand:

1. Releases ownership of the managed object without deleting it.
2. Returns a pointer to the managed object.
3. Sets the `unique_ptr` to null.

Here's an example:


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

class Character {
public:
  std::string Name;
};

int main() {
  auto Gandalf{std::make_unique<Character>("Gandalf")};
  std::cout << "Before release: " << Gandalf->Name << '\n';

  Character* RawPtr{Gandalf.release()}; //<h>
  std::cout << "After release: "
      << (Gandalf ? Gandalf->Name : "nullptr")
      << '\n';
  std::cout << "Raw pointer: " << RawPtr->Name << '\n';

  delete RawPtr; // Don't forget to delete!
}
```


```plain text
//<o>
Before release: Gandalf
After release: nullptr
Raw pointer: Gandalf
```


## Key Differences


Memory Management:

- `reset()` handles memory deallocation for you.
- `release()` leaves memory management to you.

Ownership:

- `reset()` can transfer ownership to the `unique_ptr`.
- `release()` transfers ownership away from the `unique_ptr`.

Return Value:

- `reset()` doesn't return anything.
- `release()` returns the raw pointer.

In general, `reset()` is safer and more commonly used, as it handles memory management automatically. Use `release()` with caution, typically when you need to transfer ownership to a different memory management scheme.

Reset vs Release for Unique Pointers

Yes, you can use `std::unique_ptr` with C-style APIs that expect raw pointers. This is actually one of the strengths of smart pointers - they can seamlessly integrate with existing code that uses raw pointers. However, there are a few things to keep in mind when doing so.


## Using `get()` for Read-Only Access


When you need to pass the raw pointer to a function that doesn't take ownership (i.e., doesn't delete the pointer), you can use the `get()` member function of `std::unique_ptr`. This returns the underlying raw pointer without affecting ownership.


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

class Character {
public:
  std::string Name;
};

// A C-style function that expects a raw pointer
void PrintCharacterName(const Character* Char) {
  std::cout << "Character name: " << Char->Name << '\n';
}

int main() {
  auto Legolas{std::make_unique<Character>("Legolas")};
  PrintCharacterName(Legolas.get()); //<h>
}
```


```plain text
//<o>
Character name: Legolas
```


## Passing to Functions That Take Ownership


If you need to pass your `unique_ptr` to a function that takes ownership (i.e., it's responsible for deleting the pointer), you should use the `release()` method to cause the unique pointer to give up ownership:


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

class Character {
public:
  std::string Name;
};

// A function that takes ownership of the pointer
void TakeOwnershipOfCharacter(Character* Char) {
  // Do something with Char
  delete Char;
}

int main() {
  auto Gimli{std::make_unique<Character>("Gimli")};
  TakeOwnershipOfCharacter(Gimli.release()); //<h>
  // Gimli is now nullptr
}
```


## Receiving Raw Pointers from C-style APIs


When receiving a raw pointer from a C-style API, you can wrap it in a `unique_ptr`:


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

class Character {
public:
  std::string Name;
};

// A C-style function that returns a raw pointer
Character* CreateCharacter(const char* Name) {
  return new Character(Name);
}

int main() {
  std::unique_ptr<Character> Aragorn{ //<h>
      CreateCharacter("Aragorn") //<h>
  };                                  //<h>

  // Aragorn will be automatically deleted
  // when it goes out of scope
}
```


## Caution with Temporary Access


Be careful when using `get()` with functions that might store the pointer for later use:


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

class Character {
public:
  std::string Name;
};

std::vector<Character*> CharacterRegistry;

void RegisterCharacter() {
  auto Boromir{std::make_unique<Character>("Boromir")};
  CharacterRegistry.push_back(Boromir.get());//<w>
}

int main() {
  RegisterCharacter();

  // Dangerous! CharacterRegistry now has
  // a dangling pointer
}
```


In this case, `CharacterRegistry` will have a dangling pointer once `Boromir` goes out of scope and is deleted.


Remember, when using `unique_ptr` with C-style APIs, you're responsible for ensuring that ownership semantics are respected. Always be clear about who owns the pointer and who is responsible for deleting it.

Unique Pointers with C-style APIs

Returning a `std::unique_ptr` from a function is a great way to transfer ownership of dynamically allocated objects. It's both efficient and safe, as it clearly communicates the ownership transfer to the caller. Here are some best practices for returning `unique_ptr` from functions:


## 1. Return by Value


The most straightforward and recommended way is to return the `unique_ptr` by value:


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

class Character {
public:
  std::string Name;
};

std::unique_ptr<Character> CreateCharacter(
  const std::string& Name
) {
  return std::make_unique<Character>(Name); //<h>
}

int main() {
  auto Frodo{CreateCharacter("Frodo")};
  // Frodo now owns the Character object
}
```


This approach is efficient because of return value optimization (RVO) and move semantics in modern C++.


## 2. Use `std::make_unique()`


As shown above, prefer using `std::make_unique()` to create the `unique_ptr`. It's more exception-safe and can be more efficient than manually calling `new`.


## 3. Avoid Naked `new`


Try to avoid using naked `new` in your function. If you must, wrap it immediately in a `unique_ptr`:


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

class Character {
 public:
  std::string Name;
};

std::unique_ptr<Character> CreateComplexCharacter(
  /*...*/
) {
  Character* RawPtr{new Character("Gandalf")};
  // Do some complex initialization...
  return std::unique_ptr<Character>(RawPtr); //<h>
}
```


## 4. Return `nullptr` When Appropriate


If your function might fail to create an object, returning a `nullptr` `unique_ptr` is a valid way to signal this:


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

class Character {
public:
  std::string Name;
};

std::unique_ptr<Character> TryCreateCharacter(
  const std::string& Name
) {
  if (Name.empty()) {
    return nullptr; //<h>
  }
  return std::make_unique<Character>(Name);
}

int main() {
  auto MaybeCharacter{TryCreateCharacter("")};
  if (MaybeCharacter) {
    std::cout << "Character created: "
        << MaybeCharacter->Name;
  } else {
    std::cout << "Failed to create character";
  }
}
```


```plain text
//<o>
Failed to create character
```


## 5. Consider Returning by `std::unique_ptr&&`


In some cases, you might want to return an rvalue reference to a `unique_ptr`:


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

class Character {
public:
  std::string Name;
};

std::unique_ptr<Character>&& CreateCharacterRef(
  const std::string& name
) {
  static std::unique_ptr<Character> character{
    new Character(name)
  };

  // Re-initialize the static unique_ptr
  character.reset(new Character(name));

  // Return an rvalue reference
  return std::move(character); 
}

int main() {
  std::unique_ptr<Character> character =
    CreateCharacterRef("John Doe");

  if (character) {
    std::cout << "Character Name: "
    << character->Name;
  }
}
```


```plain text
//<o>
Character Name: John Doe
```


This can be useful in specific scenarios, but be cautious as it can lead to dangling references if not used correctly.


Remember, when you return a `unique_ptr`, you're transferring ownership to the caller. The caller becomes responsible for the lifetime of the object. This ownership transfer is clear and explicit, which is one of the main advantages of using `unique_ptr`.

Returning Unique Pointers from Functions

Using `std::unique_ptr` in a class that needs to be copyable presents a challenge because `unique_ptr` is not copyable by design. However, there are several strategies you can employ depending on your specific needs:


## 1. Deep Copy


If you want each copy of your class to have its own independent copy of the managed object, you can implement a deep copy:


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

class Weapon {
public:
  std::string Name;

  Weapon(const std::string& Name)
    : Name{Name}{}
};

class Character {
  std::unique_ptr<Weapon> WeaponPtr;
  std::string Name;

public:
  Character(const std::string& Name,
            const std::string& WeaponName)
    : WeaponPtr{
        std::make_unique<Weapon>(WeaponName)},
      Name{Name}{}

  // Copy constructor //<h>
  Character(const Character& Other)
    : WeaponPtr{
        Other.WeaponPtr
          ? std::make_unique<Weapon>(
            *Other.WeaponPtr)
          : nullptr},
      Name{Other.Name}{}

  // Copy assignment operator //<h>
  Character& operator=(const Character& Other){
    if (this != &Other) {
      WeaponPtr =
        Other.WeaponPtr
          ? std::make_unique<Weapon>(
            *Other.WeaponPtr)
          : nullptr;
      Name = Other.Name;
    }
    return *this;
  }

  // Move constructor and assignment operator...
};
```


This approach creates a new `Weapon` object for each copy of `Character`.


## 2. Shared Ownership


If you want multiple `Character` objects to share the same `Weapon`, consider using `std::shared_ptr` instead:


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

class Weapon {
public:
  std::string Name;
};

class Character {
  std::shared_ptr<Weapon> WeaponPtr;//<h>
  std::string Name;

public:
  Character(const std::string& Name,
            const std::string& WeaponName)
    : WeaponPtr{
        std::make_shared<Weapon>(WeaponName)},
      Name{Name}{ }

  // Copy constructor and assignment operator
  // are automatically generated
};
```


This allows multiple `Character` objects to share ownership of the same `Weapon`.


## 3. Pointer to `unique_ptr`


If you want to maintain unique ownership but allow the pointer itself to be shared, you can use a pointer to a `unique_ptr`:


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

class Weapon {
public:
  std::string Name;
};

class Character {
  std::unique_ptr<Weapon>* WeaponPtr;//<h>
  std::string Name;

public:
  Character(const std::string& Name,
            std::unique_ptr<Weapon>& Weapon)
    : WeaponPtr{&Weapon},
      Name{Name}{ }

  // Copy constructor and assignment operator
  // can now be generated automatically
};

int main(){
  auto Sword{std::make_unique<Weapon>("Sword")};
  Character Aragorn{"Aragorn", Sword};

  // This is now possible
  Character AragornCopy{Aragorn};
}
```


Be cautious with this approach, as it can lead to dangling pointers if the original `unique_ptr` is destroyed.


## 4. Optional Copying


You might decide that copying should be allowed, but the copied object doesn't get the `unique_ptr`:


```c++
#include <memory>
#include <optional>
#include <string>

class Weapon {
public:
  std::string Name;
};

class Character {
  std::unique_ptr<Weapon> WeaponPtr;
  std::string Name;

public:
  Character(const std::string& Name,
            const std::string& WeaponName)
    : WeaponPtr{
        std::make_unique<Weapon>(WeaponName)},
      Name{Name}{}

  Character(const Character& Other)
    : WeaponPtr{nullptr}, Name{Other.Name}{}

  std::optional<std::string>
  GetWeaponName() const{
    return WeaponPtr
             ? std::optional<std::string>{
               WeaponPtr->Name}
             : std::nullopt;
  }
};
```


In this approach, copied `Character` objects don't have a weapon, but you can still access the weapon name if it exists.


## 5. Clone Method


Instead of making the class itself copyable, you could provide a `Clone()` method:


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

class Weapon {
public:
  std::string Name;
};

class Character {
  std::unique_ptr<Weapon> WeaponPtr;
  std::string Name;

public:
  Character(const std::string& Name,
            const std::string& WeaponName)
    : WeaponPtr{
        std::make_unique<Weapon>(WeaponName)},
      Name{Name}{}

  std::unique_ptr<Character> Clone() const{
    auto NewCharacter{
      std::make_unique<Character>(Name, "")};
    if (WeaponPtr) {
      NewCharacter->WeaponPtr =
        std::make_unique<Weapon>(*WeaponPtr);
    }
    return NewCharacter;
  }
};
```


This allows users to explicitly create copies when needed, while keeping the class non-copyable by default.


Each of these approaches has its pros and cons, and the best choice depends on your specific use case and requirements. Consider the semantics you want for your `Character` class and choose the approach that best fits your needs.

Copyable Classes with Unique Pointers

<Excerpt>


For the rest of this chapter, we'll focus on memory management.  This is a complex topic, so it's normal to struggle with these lessons.  Most programming languages do not allow developers to intervene in memory management, so this topic can be difficult even for those already familiar with programming.


In our previous lessons, we've primarily worked with _**stack memory**_. Stack memory is straightforward and efficient, automatically managing the lifecycle of our variables. We introduced stack memory briefly earlier in the course:


<LessonPromo url="intro-to-programming/dangling-pointers" title="Dangling Pointers and References" description="Learn about an important consideration when returning pointers and references from functions" />


Whilst simple programs can rely entirely on stack memory, it has some limitations that means we need to mix in other techniques in more complex programs.  Limitations of stack memory include:

1. Scope-limited: Variables in stack memory are destroyed when they go out of scope.  This prevents us from fully controlling the lifecycle of our objects
2. Fixed size: Stack memory is allocated at compile-time, so we can't create dynamic data structures that grow or shrink as needed.
3. Size constraints: The stack size is usually much smaller than the heap, limiting the amount of data we can store.

To overcome these limitations, C++ provides _**dynamic memory allocation**_ using the _**heap**_. We'll dive deeper into dynamic memory in a dedicated chapter in the next course, but for now, let's see a brief overview.


</Excerpt>


## Dynamic Memory and Memory Ownership


Dynamic memory allows us to allocate memory at runtime, giving us more flexibility in managing our program's resources. However, this flexibility comes at a cost: dynamic memory management is error-prone. Common issues include:

1. Memory leaks: Forgetting to deallocate memory, leading to resource waste.
2. Dangling pointers: Using pointers that point to already freed memory.
3. Double deletion: Accidentally freeing the same memory twice.

To mitigate these issues, we can implement the design pattern of _**memory ownership**_. This concept suggests that resources (like objects stored in dynamically allocated memory) should have clear owners responsible for their lifecycle. We can imagine that certain objects or functions "own" other resources, managing their creation and destruction.


We saw an example of this in the previous lesson - behind the scenes, the `std::vector` class assumes ownership of the objects it contains, and manages an area of dynamic memory to store these objects.


<LessonPromo url="intro-to-programming/std-vector" title="Dynamic Arrays using `std::vector`" description="Explore the fundamentals of dynamic arrays with an introduction to `std::vector`" />


_**Smart pointers**_ are one way we can implement this ownership model in our own code.  In a sense, they try to give us the flexibility of dynamic memory allocation, with the simplicity of stack memory allocation where memory is automatically released when it is no longer needed.


<Ad />


## Smart Pointers


The simplest form of smart pointer is a _**unique pointer**_, an implementation of which is available in the standard library as `std::unique_ptr`.  Like any pointer, a unique pointer points to an object in memory.  The "unique" refers to the idea that it should be the _**only**_ unique pointer that points to that object.


As such, we can imagine that the function or object that holds the unique pointer has exclusive ownership of the object that the pointer points to.


Unique pointers implement restrictions to help enforce this design.  For example, we'll see later in this lesson that it is difficult to create a copy of a unique pointer, as doing so would mean we now have two unique pointers pointing to the same object, contradicting the uniqueness.


## Using `std::make_unique()`


By including `<memory>`, we gain access to the `std::make_unique()` function.  Using this function is the preferred way of creating unique pointers:


```c++
#include <memory>

int main() {
  auto Pointer { std::make_unique<int>(42) };
}
```


The `<` and `>` within this code indicates that `std::make_unique()` is a _**template**_ function.  We cover templates in detail in the next course.


For now, we should just note that we need to pass the type of data we want to create a pointer to within the `<` and `>`.  In the previous example, we wanted to create a pointer to an `int`, so we pass `int` between the `<` and `>`


Within the `(` and `)`, we can optionally pass any arguments along to the constructor of our data type.  In previous example, we pass `42`, which will become the initial value of our `int`.


The net effect of all this is that we have:

- An `int` object allocated in the free store (dynamic memory)
- That `int` having the initial value of `42`
- A `std::unique_ptr`, which we've called `Pointer`, within the stack frame of our `main` function.  That `std::unique_ptr` is considered the sole owner of the integer that is stored in the heap.

The return type of `std::make_unique()` is a `std::unique_ptr` of the corresponding type.  For example, `std::make_unique<int>()` will return a `std::unique_ptr<int>`:


```c++
#include <memory>

int main() {
  std::unique_ptr<int> Pointer {
    std::make_unique<int>(42)
  };
}
```


When using `std::make_unique()`, many developers will elect to use `auto` type deduction:


```c++
#include <memory>

int main() {
  auto Pointer{std::make_unique<int>(42)};
}
```


This is because the type of the underlying data (eg, `int`) is included in the statement already.  Additionally, `std::make_unique()` is so ubiquitous that C++ developers soon learn that it returns a `std::unique_ptr`, so repeating this type can add noise to our code.


<Ad />


## Dereferencing Unique Pointers


Let's see an example of unique pointers with a class.  We'll use this class throughout the rest of this lesson:


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

class Character {
public:
  std::string Name;
  Character(std::string Name = "Frodo") :
    Name { Name }
  {
    std::cout << "Creating " << Name << '\n';
  }

  ~Character() {
    std::cout << "Deleting " << Name << '\n';
  }
};

int main() {
  auto FrodoPointer{
    std::make_unique<Character>("Frodo")
  };
  auto GandalfPointer{
    std::make_unique<Character>("Gandalf")
  };
}
```


This program outputs the following:


```c++
//<o>
Creating Frodo
Creating Gandalf
Deleting Gandalf
Deleting Frodo
```


As with basic pointers, which are often referred to as "raw" pointers, we can dereference smart pointers and access the object they point to using the `*` or `->` operators:


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

//<c name="Character Class (Unchanged)">
//<l>class Character {/*...*/};
class Character {
public:
  std::string Name;

  Character(std::string Name = "Frodo")
  : Name{ Name }{
    std::cout << "Creating " << Name << '\n';
  }

  ~Character(){
    std::cout << "Deleting " << Name << '\n';
  }
};
//</c>

int main(){
  auto FrodoPointer{
    std::make_unique<Character>("Frodo")
  };
  std::cout << "Logging "
    << (*FrodoPointer).Name << "\n\n";//<h>

  auto GandalfPointer{
    std::make_unique<Character>("Gandalf")
  };
  std::cout << "Logging "
    << GandalfPointer->Name << "\n\n";//<h>
}
```


```c++
//<o>
Creating Frodo
Logging Frodo

Creating Gandalf
Logging Gandalf

Deleting Gandalf
Deleting Frodo
```


## Copying Unique Pointers


Given the design intent of unique pointers, it doesn't make sense to copy them directly.  The `std::unique_ptr` class protects against this by preventing its objects from being copied.


We will cover how to implement this capability for our own classes later, thereby controlling (or preventing) the process whereby objects of our custom types are copied.


We can see this in action by trying to copy a `std::unique_ptr`:


```c++
#include <memory>

int main(){
  auto Ptr1{std::make_unique<int>(42)};
  auto Ptr2{Ptr1};  //<e>
}
```


```c++
//<oe>
error: 'std::unique_ptr': attempting to reference a deleted function
```


When working with functions, passing by value is also a form of copying, so this will also be prevented with a similar error message:


```c++
#include <memory>

void SomeFunction(std::unique_ptr<int> Num) {
  // ...
}

int main(){
  auto Ptr{std::make_unique<int>(42)};
  SomeFunction(Ptr);//<e>
}
```


```c++
//<oe>
error: 'std::unique_ptr': attempting to reference a deleted function
```


Of course, there are countless situations where we need to pass a pointer to a function.  For those scenarios, smart pointers implement the `get()` function, which returns the underlying raw pointer.


This allows other parts of our code to access our objects, without creating copies of our unique pointers:


```c++
#include <memory>

void SomeFunction(int* Num) {//<h>
  // ...
}

int main() {
  auto Ptr{std::make_unique<int>(42)};
  SomeFunction(Ptr.get());//<h>
}
```


Within the memory ownership paradigm, we can imagine that any function that accepts a raw pointer to a resource is simply _**requesting access**_ to that resource, but not requesting ownership.  The resource is owned by whoever has the `std::unique_ptr` to it.


For scenarios where we want to _**transfer ownership**_ of the resource, we can use `std::move()`.


<Ad />


## Transferring Ownership using `std::move()`


Sometimes, we want to transfer ownership of a resource from one unique pointer to another.


This is where `std::move()` comes in handy. It's a function available in the `<utility>` header that allows us to transfer ownership of a unique pointer.


This mechanism allows us to transfer ownership of resources between different parts of our program, ensuring that at any given time, there's only one owner of the resource.


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

void TakeOwnership(std::unique_ptr<int> Num) {
  std::cout << "TakeOwnership function now "
    "owns the pointer.\n";
  std::cout << "Value: " << *Num << '\n';
}

int main() {
  auto Number{std::make_unique<int>(42)};
  std::cout << "main function owns the pointer.\n";

  TakeOwnership(std::move(Number)); //<h>

  // Number is now in a "moved-from" state
  if (Number == nullptr) {
    std::cout << "Number no longer owns any object.";
  }
}
```


```c++
//<o>
main function owns the pointer.
TakeOwnership function now owns the pointer.
Value: 42
Number no longer owns any object.
```


In this example:

1. We create a `std::unique_ptr` called `Number` in the `main` function.
2. We use `std::move()` to transfer ownership of the integer to the `TakeOwnership()` function.
3. After the move, `Number` in `main` no longer owns any object (it becomes a null pointer).

It's important to note that after using `std::move()`, the original pointer (`Number` in this case) is left in a valid but unspecified state. It's safe to reassign it or let it go out of scope, but you shouldn't try to use the object it previously owned.


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

void TakeOwnership(std::unique_ptr<int> Num) {}

int main() {
  auto Number{std::make_unique<int>(42)};
  TakeOwnership(std::move(Number)); //<h>
  std::cout << *Number; //<w>
}
```


Most compilers can detect this, and will generate a warning:


```c++
//<oe>
Warning: Use of a moved from object: 'Number'
```


## Summary


In this lesson, we explored the concept of unique pointers, a crucial component of modern memory management. Let's briefly recap the key points:

1. **Understanding Memory Ownership**: We've learned what smart pointers are and how they implement an ownership model for objects in dynamically allocated memory
2. **Memory Management Simplified**: We explored how smart pointers automate memory management, thereby reducing the chances of memory-related errors.
3. **Creating Unique Pointers using** `std::make_unique()`: We now know how to create unique pointers using `std::make_unique()`,
4. **Access and Ownership Transfer:** We learned how to give other functions access to our resources through a raw pointer, generated by `get()`.  We also covered how to transfer ownership of resources using `std::move()`.

Reorganized course to move memory management lessons later

Expanded introduction and moved section on `const` smart pointers to later lesson

Abstract art representing computer programming

std::unique_ptr

How to: Create and use unique_ptr instances

Back to Basics: Smart Pointers - Rainer Grimm - CppCon 2020

GotW #89 Solution: Smart Pointers

Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14

When is std::unique_ptr useful?

How to Use the Pimpl Idiom in C++

Transferring ownership with unique_ptr

{CPP}Dive into C++ memory management with our comprehensive guide on unique pointers and memory ownership. Learn to write safer, more efficient code and prevent memory leaks.

{CPP}C++ Memory Management: Mastering Unique Pointers and Ownership

Transferring Ownership using `std::move()`

Memory Ownership and Smart Pointers

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers