Memory Ownership with Smart Pointers, and std::unique_ptr

When we’re writing complicated software that is intended to run for a long time, memory management can get incredibly complex. For example, the server for an online game may be managing hundreds of thousands of objects, in a highly dynamic environment.

Furthermore, these processes may need to run for weeks or months between restarts so even the smallest memory leak will cause issues.

In these environments, we need to be more strategic in how we manage memory - we can’t rely on ad hoc calls to delete scattered through our code base.

The common way to design this is through a system of ownership. Our objects, and the memory used to store them, are owned by other objects. Those objects are, in turn, owned by further objects. At the top of this hierarchy will be a stack frame - a function.

Designing our applications with the concept of memory ownership greatly simplifies our memory management. This is because when an object gets deleted from memory, all the objects that were owned by it also get deleted. No longer do we need to scatter calls to delete throughout our code, with all the problems that entails.

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 smart pointer that points to that object.

As such, the function or object that has the unique pointer owns 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.

Creating Unique Pointers with make_unique

By including memory, we gain access to the std::make_unique function, which is the preferred way of creating unique pointers:

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

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 thereby creating a pointer to an int that has an initial value of 42.

The return type of make_unique is a std::unique_ptr of the corresponding type:

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

By convention, we just use auto with the return value of make_unique. 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 there’s no benefit in constantly repeating that within 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
4using namespace std;
5
6class Character {
7public:
8  string Name;
9  Character(string Name = "Frodo") :
10    Name { Name }
11  {
12    cout << "Creating " << Name << endl;
13  }
14
15  ~Character() {
16    cout << "Deleting " << Name << endl;
17  }
18};
19
20int main() {
21    auto FrodoPointer { make_unique<Character>("Frodo") };
22    auto GandalfPointer { make_unique<Character>("Gandalf") };
23}
24

This program outputs the following:

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

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:

1int main() {
2  auto FrodoPointer { make_unique<Character>("Frodo") };
3  cout << "Logging " << (*FrodoPointer).Name << endl << endl;
4
5  auto GandalfPointer { make_unique<Character>("Gandalf") };
6  cout << "Logging " << GandalfPointer->Name << endl << endl;
7}
8

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

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 does take some steps to prevent this:

1auto FrodoPointer1 { make_unique<Character>() };
2auto FrodoPointer2 { FrodoPointer1 };
3

Line 2 will result in a compilation error, stating the copy constructor has been deleted. 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:

1void LogName(unique_ptr<Character> Character) {
2  cout << "Logging " << Character->Name << endl;
3}
4
5int main() {
6  auto FrodoPointer { make_unique<Character>() };
7  LogName(FrodoPointer);
8}
9

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:

1void LogName(Character* Character) {
2  cout << "Logging " << Character->Name << endl;
3}
4
5int main() {
6  auto FrodoPointer { make_unique<Character>() };
7  LogName(FrodoPointer.get());
8}
9

1Creating Frodo
2Logging Frodo
3Deleting Frodo
4

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 them, too. 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> Number) {
5  // Do things
6}
7
8int main() {
9  auto Number { std::make_unique<int>() };
10  TakeOwnership(std::move(Number));  
11}
12

Lets see an example with our Character class:

1void LogName(unique_ptr<Character> Character) {
2  cout << "Logging " << Character->Name << endl;
3}
4
5int main() {
6  auto FrodoPointer { make_unique<Character>("Frodo") };
7  LogName(move(FrodoPointer));
8
9  auto GandalfPointer { make_unique<Character>("Gandalf") };
10  LogName(move(GandalfPointer));
11}
12

Note carefully the order of logs here:

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

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

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.

Attempting to use our pointer after it has been transferred will result in an error:

1auto FrodoPointer { make_unique<Character>() };
2LogName(move(FrodoPointer));
3cout << FrodoPointer->Name;
4

Releasing Smart Pointers

We can call release() on a smart pointer. After calling release, the smart pointer will no longer manage the underlying object. The release will not delete the object, but 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 nullptr

1#include <memory>
2#include <iostream>
3
4int main() {
5  using namespace std;
6  auto SmartPointer { make_unique<Character>() };
7  Character* RawPointer { SmartPointer.release() };
8
9  // This will be a null pointer
10  cout << "Smart: " << SmartPointer.get() << endl;
11
12  cout << "Raw: " << RawPointer << endl;
13  delete RawPointer;
14}
15

The output is as follows:

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

Updating Smart Pointers with Reset

The reset function will delete the managed object. After calling reset, the get function will return a nullptr:

1int main() {
2  auto FrodoPointer { make_unique<Character>() };
3  FrodoPointer.reset();
4  cout << FrodoPointer.get() << endl; // nullptr
5}
6

1Creating Frodo
2Deleting Frodo
30
4

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

1int main() {
2  auto Pointer { make_unique<Character>("Frodo") };
3  cout << "Logging " << Pointer->Name << endl;
4  
5  Pointer.reset(new Character {"Gandalf"});
6  cout << "Logging " << Pointer->Name << endl;
7}
8

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

Note, when passing an argument to reset, it’s important to ensure that it is pointing at an object in the free store. The following will cause issues:

1int main() {
2  auto Pointer { make_unique<Character>() };
3  Character Gandalf;
4
5  // Gandalf is allocated on the stack - it is going to
6  // be deleted when this function ends - storing it in
7  // a smart pointer does not make sense
8  Pointer.reset(&Gandalf);
9}
10

Similarly, we should ensure the memory location is not already being managed. Having two unique pointers managing the same area of memory is a recipe for disaster:

1int main() {
2  auto Pointer1 { make_unique<Character>("Frodo") };
3  auto Pointer2 { make_unique<Character>("Gandalf") };
4
5  // We don't want 2 smart pointers managing the same object
6  // Using release() instead of get() would work here
7  Pointer1.reset(Pointer2.get());
8}
9

Swapping Smart Pointers

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

1int main() {
2  auto Pointer1 { make_unique<Character>("Frodo") };
3  auto Pointer2 { make_unique<Character>("Gandalf") };
4
5  cout << "1: " << Pointer1->Name << endl;
6  cout << "2: " << Pointer2->Name << endl;
7  
8  Pointer1.swap(Pointer2);
9
10  cout << "1: " << Pointer1->Name << endl;
11  cout << "2: " << Pointer2->Name << endl;
12}
13

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

const Unique Pointers

As with raw pointers, unique pointers can be const:

1#include <memory>
2
3int main() {
4  const auto Pointer {
5    std::make_unique<int>(42)
6  };
7
8  // Error: cannot reset a const pointer
9  Pointer.reset();
10}
11

Unique Pointers to const

Similarly, the object that a unique pointer points to can also be const:

1#include <memory>
2
3int main() {
4  auto Pointer {
5    std::make_unique<const int>(42)
6  };
7
8  // Error - cannot modify a const int
9  (*Pointer)++;
10}
11

Both the pointer and the object can be const:

1const auto Pointer {
2  std::make_unique<const int>(42)
3};
4