Shared Pointers using std::shared_ptr

So far in this section, we’ve coverered how smart pointers are tools for managing dynamically allocated memory, ensuring that memory is automatically deallocated when it is no longer needed.

The C++ standard library provides a few variations of smart pointers. std::unique_ptr and std::shared_ptr are the most commonly used, but they serve different purposes:

Unique Pointers

Unique pointers, such as std::unique_ptr enforces unique ownership of the memory resource it manages. It implies that only one unique pointer can point to a specific resource at any time.

When the std::unique_ptr is destroyed or revokes its ownership through the std::move(), release() or reset() methods, the resource it points to is automatically deallocated. This type of smart pointer is lightweight and efficient, making it an ideal choice for most single-owner scenarios.

We covered unique pointers in detail a dedicated lesson:

Smart Pointers and std::unique_ptr

An introduction to memory ownership using smart pointers and std::unique_ptr in C++

Shared Pointers

Unlike std::unique_ptr, std::shared_ptr allows multiple pointers to share ownership of a single resource. The resource is only deallocated when the last std::shared_ptr pointing to it is destroyed or reset.

This shared ownership is managed through reference counting - an internal mechanism that keeps track of how many std::shared_ptr instances are managing the same resource. This comes at a performance cost, so in general, std::unique_ptr, should be our default choice of smart pointer.

However, there are scenarios where an object needs to be accessed and managed by multiple owners. In such cases, std::shared_ptr becomes invaluable, and we’ll cover it in detail in this lesson.

Similar to the previous lesson, we’ll be using the following Character class to demonstrate how shared pointers work.

It has a simple constructor and destructor that logs when objects are created and destroyed, so we can better understand when these steps happen:

1#include <iostream>
2
3class Character {
4 public:
5  std::string Name;
6  Character(std::string Name = "Frodo")
7  : Name{Name} {
8    std::cout << "Creating " << Name << '\n';
9  }
10
11  ~Character(){
12    std::cout << "Deleting " << Name << '\n';
13  }
14};
15
16int main() {
17  // ...
18}

std::make_shared()

We previously saw how the helper function std::make_unique created a std::unique_ptr for us. Predictably, we also have std::make_shared to create a std::shared_ptr:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto FrodoPointer {
20    std::make_shared<Character>()
21  };
22}

The std::make_shared() function creates an object of the type specified between the < and > tokens, allocated in dynamic memory. It returns a std::shared_ptr of that same type.

For example, std::make_shared<Character>() will create a Character in dynamic memory, and return a std::shared_ptr<Character> that points to it.

Any function arguments passed to std::make_shared() are forwarded to the underlying type’s constructor:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto GandalfPointer {
20    std::make_shared<Character>("Gandalf")
21  };
22}

Using Shared Pointers

In most ways, shared pointers can be used in the same way as unique pointers.

Dereferencing Shared Pointers using * and ->

We can dereference shared pointers using the * and -> operators:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto FrodoPointer{
20    std::make_shared<Character>()
21  };
22
23  std::cout << (*FrodoPointer).Name << '\n';
24  std::cout << FrodoPointer->Name << '\n';
25  std::cout << "Main Function Ending" << '\n';
26}

1Creating Frodo
2Frodo
3Frodo
4Main Function Ending
5Deleting Frodo

Accessing the Raw Pointer using get()

We can access the raw memory address being managed by a shared pointer using the get() method:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18void LogName(const Character* Ptr){
19  std::cout << Ptr->Name << '\n';
20}
21
22int main() {
23  auto FrodoPointer{
24    std::make_shared<Character>()};
25  LogName(FrodoPointer.get());
26  std::cout << "Main Function Ending" << '\n';
27}

1Creating Frodo
2Frodo
3Main Function Ending
4Deleting Frodo

Transferring Ownership using std::move()

A shared pointer can also transfer its ownership of a resource using std::move():

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18void TakeOwnership(
19  std::shared_ptr<Character> Ptr
20){
21  std::cout << Ptr->Name << '\n';
22}
23
24int main() {
25  auto FrodoPointer{
26    std::make_shared<Character>()
27  };
28
29  TakeOwnership(std::move(FrodoPointer));
30
31  std::cout << "Main Function Ending" << '\n';
32}

As before with unique pointers, note how our Character is now being deleted at the end of the TakeOwnership() function, rather than at the end of main:

1Creating Frodo
2Frodo
3Deleting Frodo
4Main Function Ending

Swapping Ownership using swap()

We also have access to swap(), allowing two shared pointers to exchange ownership of the objects they’re managing:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto Pointer1{
20    std::make_shared<Character>("Frodo")
21  };
22  auto Pointer2{
23    std::make_shared<Character>("Gandalf")
24  };
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

Resetting Ownership using reset()

Similar to unique pointers, a shared pointer can revoke its ownership of the underlying resource using reset(). Below, note how our Character is automatically deleted as soon as our shared pointer revokes its ownership over it:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto Pointer{std::make_shared<Character>()};
20  Pointer.reset();
21  std::cout << "Main Function Ending" << '\n';
22}

1Creating Frodo
2Deleting Frodo
3Main Function Ending

The reset() method can also be used to replace the managed object with a new one of the same type (or convertible to the same type):

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto Pointer{
20    std::make_shared<Character>("Frodo")
21  };
22
23  Pointer.reset(new Character{"Gandalf"});
24
25  std::cout << "Main Function Ending" << '\n';
26}

1Creating Frodo
2Creating Gandalf
3Deleting Frodo
4Main Function Ending
5Deleting Gandalf

Unlike the unique pointer variation, the shared pointer’s reset() method may not cause the object to be deleted.

Smart pointers only delete the underlying resource if the resource has no owners.

With unique pointers, by design, the resource only has one owner. So, after calling reset() on a unique pointer, the resource will have no owners, so it will automatically be deleted.

However, there can be multiple shared pointers sharing ownership of the same resource. A single shared pointer being deleted, or revoking its ownership through reset() or move(), doesn’t necessarily mean the underlying resource will be deleted.

There may be other shared pointers that still have an ownership stake over it. It will only be destroyed after all of those shared pointers are destroyed, or they give up ownership.

In the rest of this lesson, we show how we can set up a collection of shared pointers such that they can all share ownership of an underlying resource.

Sharing Ownership

The key difference between unique and shared pointers is that, predictably, shared pointers can be shared. This is done simply by creating copies of them:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18int main() {
19  auto Pointer1{std::make_shared<Character>()};
20  auto Pointer2{Pointer1};
21}

Most commonly, these copies are created by passing the shared pointer by value into a function, or setting it as a member variable on some object using the assignment operator =:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
17
18struct Party {
19  std::shared_ptr<Character> Leader;
20};
21
22void SomeFunction(std::shared_ptr<Character> C){
23  // ...
24}
25
26int main() {
27  auto Pointer{std::make_shared<Character>()};
28  SomeFunction(Pointer);
29
30  Party MyParty;
31  MyParty.Leader = Pointer;
32}

This is the key mechanism that allows a resource to have multiple owners. Every function or object that has a copy of the shared pointer is considered an owner.

The underlying resource is deleted only when all of its owners are deleted.

Getting the Owner Count using use_count()

We can see how many owners a shared pointer has using the use_count() class function:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
19
20struct Party {
21  std::shared_ptr<Character> Leader;
22};
23
24int main(){
25  auto Pointer{std::make_shared<Character>()};
26  std::cout << "Owners: "
27    << Pointer.use_count() << '\n';
28
29  Party MyParty;
30  MyParty.Leader = Pointer;
31  std::cout << "Owners: "
32    << Pointer.use_count() << '\n';
33}

1Creating Frodo
2Owners: 1
3Owners: 2
4Deleting Frodo

A more complex example is below, showing the effect of functions like std::move() and reset() on the the ownership model:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
18
19struct Party {
20  std::shared_ptr<Character> Leader;
21};
22
23void SomeFunction(std::shared_ptr<Character> C){
24  // ...
25}
26
27int main(){
28  auto Frodo{std::make_shared<Character>()};
29  auto Party1{std::make_unique<Party>()};
30  auto Party2{std::make_unique<Party>()};
31
32  std::cout << "Frodo has "
33    << Frodo.use_count()
34    << " owner (the main function)\n\n";
35
36  std::cout << "Giving Party1 a copy\n";
37  Party1->Leader = Frodo;
38  std::cout << "Frodo has "
39    << Frodo.use_count()
40    << " owners (main and Party1)\n\n";
41
42  std::cout << "Moving main's ownership"
43    " to Party2\n";
44  Party2->Leader = std::move(Frodo);
45  std::cout << "Frodo has "
46    << Party1->Leader.use_count()
47    << " owners (Party1 and Party2)\n\n";
48
49  std::cout << "Resetting Party2\n";
50  Party2.reset();
51
52  std::cout << "Frodo has "
53    << Party1->Leader.use_count()
54    << " owner left (Party1)\n\n";
55
56  std::cout << "Resetting Party1\n"
57    << "Frodo will have no owners left so he"
58    "\nwill be automatically deleted:\n";
59  Party1.reset();
60
61  std::cout << "\nMain function ending";
62}

1Creating Frodo
2Frodo has 1 owner (the main function)
3
4Giving Party1 a copy
5Frodo has 2 owners (main and Party1)
6
7Moving main's ownership to Party2
8Frodo has 2 owners (Party1 and Party2)
9
10Resetting Party2
11Frodo has 1 owner left (Party1)
12
13Resetting Party1
14Frodo will have no owners left so he
15will be automatically deleted:
16Deleting Frodo
17
18Main function ending

Pitfall: Not Copying Shared Pointers

The most common mistake people make with shared pointers is not creating them correctly.

The mechanism that enables a collection of shared pointers to co-ordinate their ownership is predicated on new pointers in the collection being created from existing pointers.

Creating a new shared pointer in any other way will bypass this mechanism, even if the shared pointer happens to be pointing to the same object.

For example, the following code is not copying the shared pointer:

1#include <memory>
2#include <iostream>
3
4int main(){
5  int x{42};
6  std::shared_ptr<int> Pointer1{&x};
7  std::shared_ptr<int> Pointer2{&x};
8  std::cout << "Owners: "
9    << Pointer1.use_count();
10}

1Owners: 1

In the above code, even though Pointer1 and Pointer2 are managing the same object, they’re not aware of each other. This means they cannot correctly determine when the object should be deleted, which in turn will cause memory issues.

Therefore, when we want to share ownership of an object, we should ensure we’re instantiating new pointers from existing ones:

1#include <memory>
2#include <iostream>
3
4int main(){
5  int x{42};
6  std::shared_ptr<int> Pointer1{&x};
7  std::shared_ptr<int> Pointer2{Pointer1};
8  std::cout << "Owners: "
9    << Pointer1.use_count();
10}

1Owners: 2

Shared Pointer Casting

Just like raw pointers can be cast to other types with dynamic_cast and static_cast, so too can shared pointers.

We have dedicated lessons on static and dynamic casting available here:

Downcasting

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

The only difference is, for shared pointers, we instead use std::dynamic_pointer_cast and std::static_pointer_cast. Rather than returning raw pointers, these functions return std::shared_ptr instances.

If std::dynamic_pointer_cast fails, it returns an "empty" shared pointer - that is, one that is not managing any underlying object.

Such a pointer evaluates to false when converted to a boolean therefore code using std::dynamic_pointer_cast looks very similar to code using dynamic_cast:

1#include <iostream>
2#include <memory>
3using std::shared_ptr;
4
5class Character {
6public:
7  virtual ~Character() = default;
8};
9
10class Monster : public Character {};
11
12void Downcast(shared_ptr<Character> Attacker){
13  auto MonsterPtr{
14    std::dynamic_pointer_cast<Monster>(Attacker)
15  };
16  if (MonsterPtr) {
17    std::cout
18      << "Cast Succeeded: It's a monster!\n";
19  } else {
20    std::cout
21      << "Cast Failed: It's not a monster!\n";
22  }
23}
24
25int main(){
26  // A character pointer pointing at a monster
27  shared_ptr<Character> CharacterPtrA{
28    std::make_shared<Monster>()
29  };
30  Downcast(CharacterPtrA);
31
32  // A character pointer pointing at a character
33  shared_ptr<Character> CharacterPtrB{
34    std::make_shared<Character>()
35  };
36  Downcast(CharacterPtrB);
37}

1Cast Succeeded: It's a monster!
2Cast Failed: It's not a monster!

Owning and Pointing At Different Objects

Shared pointers have an interesting feature where the object they are sharing ownership over does not necessarily need to be the same object they are pointing at.

This is enabled through an alternative std::shared_ptr constructor, sometimes referred to as the aliasing constructor, that accepts two arguments:

1. The object to own , in the form of a std::shared_ptr to copy
2. The object to point at, in the form of a memory address

In the following contrived example, we show the mechanism of this using integers. Alias is managing the dynamically allocated integer that has the value of 1, but is pointing at the stack-allocated integer that has a value of 2:

1#include <iostream>
2#include <memory>
3
4int main(){
5  auto One{std::make_shared<int>(1)};
6  int Two{2};
7  std::shared_ptr<int> Alias{One, &Two};
8
9  std::cout << "Number Pointed At: " << *Alias;
10}

1Number Pointed At: 2

The most useful application of this is to create a pointer that shares ownership of an object, whilst pointing to a specific member of that same object.

For example, below we have a smart pointer that points to a character’s Name field, but shares ownership of the Character as a whole.

This gives us a pointer we can use to directly access the specific object property we want, whilst also preventing the object itself from being deleted before we’re done with it:

1#include <iostream>
2#include <memory>
3
Character Class (Unchanged)|Show
4class Character {/*...*/};
18
19int main(){
20  auto Frodo{std::make_shared<Character>()};
21  std::shared_ptr<std::string> Name{
22    Frodo, &Frodo->Name
23  };
24
25  std::cout << "Name: " << *Name;
26  std::cout << "\nOwners: "
27    << Name.use_count() << '\n';
28}

1Name: Frodo
2Owners: 2

Summary

As we conclude this lesson, we've equipped ourselves with a thorough understanding of shared pointers, and the standard library’s std::shared_ptr in particular. We've seen how this type of smart pointer is using in scenarios where multiple ownership of a dynamic resource is necessary.

Key Points:

• The Role of Shared Pointers and std::shared_ptr: We've learned that std::shared_ptr is used when an object needs multiple owners, and it keeps track of how many pointers own the resource.
• Practical Functions: Functions like std::make_shared(), get(), reset(), and swap() offer us practical ways to manage and interact with shared pointers.
• Shared Pointer Memory Management: Through std::shared_ptr, we've seen another example of how smart pointers handle automatic memory management, and the implications of multiple ownerships on that process.
• Avoiding Common Mistakes: We discussed common pitfalls such as improper copying of shared pointers and how to avoid them.

With this knowledge, we’re now even better prepared to write safer and more managable programs

Looking Ahead: Weak Pointers

In our next lesson, we'll dive into std::weak_ptr, another type of smart pointer. We'll explore how weak pointers work, their relationship with shared pointers, and their practical applications.

This lesson will further enhance our understanding of memory management in C++, preparing us for more advanced projects.

Next Lesson

Weak Pointers with std::weak_ptr

A full guide to weak pointers, using std::weak_ptr. Learn what they’re for, and how we can use them with practical examples

ContinueView Course