Memory Ownership and Smart Pointers

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.

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.

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.

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 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>:

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

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

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

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.

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 to 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

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:

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

1error: '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:

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': 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:

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}

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().

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.

1#include <memory>
2#include <utility>
3#include <iostream>
4
5void TakeOwnership(std::unique_ptr<int> Num) {
6  std::cout << "TakeOwnership function now "
7    "owns the pointer.\n";
8  std::cout << "Value: " << *Num << '\n';
9}
10
11int main() {
12  auto Number{std::make_unique<int>(42)};
13  std::cout << "main function owns the pointer.\n";
14
15  TakeOwnership(std::move(Number)); 
16
17  // Number is now in a "moved-from" state
18  if (Number == nullptr) {
19    std::cout << "Number no longer owns any object.";
20  }
21}

1main function owns the pointer.
2TakeOwnership function now owns the pointer.
3Value: 42
4Number 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.

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

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

1Warning: Use of a moved from object: 'Number'

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().