Smart Pointers and std::unique_ptr

In the world of long-running, complex software like online game servers, managing memory efficiently is critical.

Imagine handling hundreds of thousands of objects without a hitch, for weeks or even months. Here, even a tiny memory leak can snowball into a major issue.

That's where strategic memory management comes in. Instead of littering your code with haphazard delete calls, we adopt a system of ownership. In this system, objects own other objects, creating a hierarchical structure of responsibility.

This approach not only cleans up our code but also ensures that when one object is deleted, all its dependents are automatically cleaned up too.

Let's dive into how we can simplify and strengthen our memory management with this smart system of ownership.

Smart Pointers and Unique Pointers

The class of objects that implement the memory ownership patterns described above is known as 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 owns the unique pointer has exclusive ownership of the object that the pointer points at.

Unique pointers implement behaviors to solidify this intent. 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 inherently undermine the uniqueness.

Creating Unique Pointers with 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:

1#include <memory>
2
3int main() {
4  auto Pointer { std::make_unique<int>(42) };
5}

The < and > within this code indicates that make_unique is a template function. We cover template functions in detail later in this 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 this case, that is an int

Within the ( and ), we can optionally pass any arguments along to the constructor of our data type. In this example, we pass 42

The net effect of all of 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 make_unique is a std::unique_ptr of the corresponding type. For example, std::make_unique<int> will return a std::unique_ptr<int> which we can specify if preferred:

1#include <memory>
2
3int main() {
4  std::unique_ptr<int> Pointer {
5    std::make_unique<int>(42)
6  };
7}

However, when using std::make_unique, it’s somewhat common to use auto type deduction.

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

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:

1#include <iostream>
2#include <memory>
3
4class Character {
5public:
6  std::string Name;
7  Character(std::string Name = "Frodo") :
8    Name { Name }
9  {
10    std::cout << "Creating " << Name << '\n';
11  }
12
13  ~Character() {
14    std::cout << "Deleting " << Name << '\n';
15  }
16};
17
18int main() {
19    auto FrodoPointer{
20      std::make_unique<Character>("Frodo")
21    };
22    auto GandalfPointer{
23      std::make_unique<Character>("Gandalf")
24    };
25}

This program outputs the following:

1Creating Frodo
2Creating Gandalf
3Deleting Gandalf
4Deleting Frodo

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

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
18
19int main(){
20  auto FrodoPointer{
21    std::make_unique<Character>("Frodo")
22  };
23  std::cout << "Logging "
24    << (*FrodoPointer).Name << "\n\n";
25
26  auto GandalfPointer{
27    std::make_unique<Character>("Gandalf")
28  };
29  std::cout << "Logging "
30    << GandalfPointer->Name << "\n\n";
31}

1Creating Frodo
2Logging Frodo
3
4Creating Gandalf
5Logging Gandalf
6
7Deleting Gandalf
8Deleting Frodo

Copying Unique Pointers

Given the design intent of unique pointers, it doesn’t make sense to copy them. As a result, the unique_ptr class takes some steps to prevent this. For example, the copy constructor has been deleted, meaning code like this will result in a compilation error:

1#include <memory>
2
3int main(){
4  auto Ptr1{std::make_unique<int>(42)};
5  auto Ptr2{Ptr1};  
6}

1error: 'std::unique_ptr':
2attempting to reference a deleted function

We will better understand copy constructors, and add them to our own classes, later in this course.

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

1#include <memory>
2
3void SomeFunction(std::unique_ptr<int> Num) {
4  // ...
5}
6
7int main(){
8  auto Ptr{std::make_unique<int>(42)};
9  SomeFunction(Ptr);
10}

1error: 'std::unique_ptr':
2attempting 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:

1#include <memory>
2
3void SomeFunction(int* Num) {
4  // ...
5}
6
7int main() {
8  auto Ptr{std::make_unique<int>(42)};
9  SomeFunction(Ptr.get());
10}

Transferring Ownership of Unique Pointers

Sometimes, we don’t just want to give other functions or objects access to our smart pointers - we want them to take ownership of the thing the pointer is managing. For those scenarios, we can call the std::move() function available within <utility>

1#include <memory>
2#include <utility>
3
4void TakeOwnership(std::unique_ptr<int> Num) {
5  // Do things
6}
7
8int main() {
9  auto Number{std::make_unique<int>()};
10  TakeOwnership(std::move(Number));
11}

Let's see an example with our Character class:

1#include <memory>
2#include <utility>
3#include <string>
4#include <iostream>
5
Character Class (Unchanged)|Show
6class Character {/*...*/};
19
20void LogName(std::unique_ptr<Character> C) {
21  std::cout << "Logging " << C->Name << '\n';
22}
23
24int main() {
25  auto FrodoPointer{
26    std::make_unique<Character>("Frodo")};
27  LogName(std::move(FrodoPointer));
28
29  auto GandalfPointer{
30    std::make_unique<Character>("Gandalf")};
31  LogName(std::move(GandalfPointer));
32}

Note carefully the order of actions from the previous program:

1Creating Frodo
2Logging Frodo
3Deleting Frodo
4Creating Gandalf
5Logging Gandalf
6Deleting Gandalf

Previously, when the main function was maintaining ownership of our smart pointers, our characters were not getting deleted until the end of the main function.

Now, because ownership is being transferred to the LogName() function each time it is called, the compiler is dutifully cleaning up our characters every time that function ends.

Note that attempting to use a pointer after ownership has been given away can result in unpredictable behavior, because the new owner of the resource may have deleted it.

However, most compilers can detect this, and notify us with a warning:

1int main(){
2  auto FrodoPointer{
3    std::make_unique<Character>("Frodo")};
4  LogName(std::move(FrodoPointer));
5
6  FrodoPointer->Name;
7}

1warning: Use of a moved-from object: FrodoPointer

Releasing Unique Pointers

A unique pointer can release ownership over a resource using the release() method.

The release() method will not delete the underlying resource. Instead, it will return the raw pointer, which lets us decide what to do with it.

After calling release(), the smart pointer’s get() function will return a nullptr:

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main() {
21  auto SmartPointer{
22    std::make_unique<Character>()
23  };
24  Character* RawPointer{
25    SmartPointer.release()
26  };
27
28  // This will be a null pointer
29  std::cout << "Smart: "
30    << SmartPointer.get() << '\n';
31
32  std::cout << "Raw: " << RawPointer << '\n';
33  delete RawPointer;
34}

The output is as follows:

1Creating Frodo
2Smart: 0
3Raw: 0x2022e70
4Deleting Frodo

Updating Smart Pointers with reset()

The reset() function will also release ownership of the underlying resource, but will also delete it.

After calling reset(), the get() function will return a nullptr:

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main() {
21  auto FrodoPointer{
22    std::make_unique<Character>()
23  };
24  FrodoPointer.reset();
25
26  // nullptr
27  std::cout << FrodoPointer.get() << '\n';
28}

1Creating Frodo
2Deleting Frodo
30

Typically, reset() is used to update the object that is being managed by the smart pointer. We can do this by passing the new raw pointer as an argument to reset():

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main() {
21  auto Pointer{
22    std::make_unique<Character>("Frodo")};
23  std::cout << "Logging "
24    << Pointer->Name << '\n';
25
26  Pointer.reset(new Character{"Gandalf"});
27  std::cout << "Logging "
28    << Pointer->Name << '\n';
29}

1Creating Frodo
2Logging Frodo
3Creating Gandalf
4Deleting Frodo
5Logging Gandalf
6Deleting Gandalf

Pitfall 1: Managing an object that is not in the free store

Note, that when passing an argument to reset, it’s important to ensure that it is pointing at an object in the free store.

The following code is attempting to use a smart pointer that is allocated on the stack, and is therefore going to be automatically deleted.

Having a smart pointer also attempting to manage its deletion will cause issues:

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main() {
21  auto Pointer{std::make_unique<Character>()};
22  Character Gandalf;
23
24  // Gandalf is allocated on the stack - it is
25  // going to be deleted when this function ends
26  // Therefore, storing it in a smart pointer
27  // does not make sense
28  Pointer.reset(&Gandalf);
29}

Pitfall 2: Managing an object that is already managed by another smart pointer

Similarly, we should ensure the memory location is not already being managed. Having two unique pointers managing the same resource bypasses their intended design, and will cause problems. Below, create a situation where we have multiple unique pointers owning the same resource - the Character called Gandalf:

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main() {
21  auto Pointer1{
22    std::make_unique<Character>("Frodo")};
23  auto Pointer2{
24    std::make_unique<Character>("Gandalf")};
25
26  // We don't want 2 unique pointers managing 
27  // the same object.  Using release()
28  // instead of get() would work here
29  Pointer1.reset(Pointer2.get());
30}

Swapping Unique Pointers

Finally, we have swap(), which accepts another smart pointer as an argument, and swaps the object being managed between the two pointers:

1#include <memory>
2#include <string>
3#include <iostream>
4
Character Class (Unchanged)|Show
5class Character {/*...*/};
19
20int main(){
21  auto Pointer1{
22    std::make_unique<Character>("Frodo")};
23  auto Pointer2{
24    std::make_unique<Character>("Gandalf")};
25
26  std::cout << "1: " << Pointer1->Name << '\n';
27  std::cout << "2: " << Pointer2->Name << '\n';
28
29  Pointer1.swap(Pointer2);
30
31  std::cout << "1: " << Pointer1->Name << '\n';
32  std::cout << "2: " << Pointer2->Name << '\n';
33}

1Creating Frodo
2Creating Gandalf
31: Frodo
42: Gandalf
51: Gandalf
62: Frodo
7Deleting Frodo
8Deleting Gandalf

const Unique Pointers

Similar to raw pointers, there are two ways we can use const with std::unique_ptr. This creates four possible combinations:

1. Non-const pointer to non-const

Most of the examples we’ve seen in this lesson have been like this. Neither the pointer nor the object it points to are const, so we can modify either:

1#include <memory>
2
3int main() {
4  auto Pointer{std::make_unique<int>(42)};
5
6  // Modify the underlying object
7  (*Pointer)++;
8
9  // Modify the pointer
10  Pointer.reset();
11}

2. Const pointer to non-const

Here, we cannot modify the pointer, but we can modify the object it points at:

1#include <memory>
2
3int main() {
4  const auto Pointer{
5    std::make_unique<int>(42)};
6
7  // Modify the underlying object
8  (*Pointer)++;
9
10  // Error - can't modify the pointer
11  Pointer.reset();
12}

3. Non-const pointer to const

Here, we can modify the pointer, but not the object it points at:

1#include <memory>
2
3int main() {
4  auto Pointer{
5    std::make_unique<const int>(42)};
6
7  // Error - can't modify the underlying object
8  (*Pointer)++;
9
10  // Modify the pointer
11  Pointer.reset();  
12}

4. Const pointer to const

Finally, both the pointer and the underlying object can be const, preventing us from modifying either:

1#include <memory>
2
3int main() {
4  const auto Pointer{
5    std::make_unique<const int>(42)};
6
7  // Error - can't modify the underlying object
8  (*Pointer)++;  
9
10  // Error - can't modify the pointer
11  Pointer.reset();  
12}

Summary

In this lesson, we delved into 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, eliminating the need for manual delete calls and 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().
5. Releasing, Resetting and Swapping: We learned about the release(), reset(), and swap() methods, and why we’d use them

Up Next: Shared Pointers

In our next lesson, we'll dive into std::shared_ptr. This type of smart pointer allows for multiple owners of a single resource, offering a different approach to memory management compared to unique pointers. We'll explore:

• How shared pointers manage resource sharing.
• The concept of reference counting in shared pointers.
• Differences and similarities between unique and shared pointers.
• Appropriate use cases for shared pointers.
• Potential pitfalls and how to avoid them.

Next Lesson

Shared Pointers using std::shared_ptr

An introduction to shared memory ownership using std::shared_ptr

ContinueView Course