C++ Shared Pointers using std::shared_ptr

For most cases, we want our objects to have a single owner. Therefore, std::unique_ptr should be our preferred way to store pointers.

However, in some cases, we need our objects to have multiple owners. This is where std::shared_ptr can help us.

Similar to the previous lesson, we’ll be using this file to demonstrate how shared pointers work:

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  // ...
22}
23

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 <memory>
2
3int main() {
4  auto FrodoPointer { std::make_shared<Character>() };
5}
6

The std::make_shared function creates an object of the type specified between the < and > tokens, and 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.

Constructor arguments can be passed between the ():

1#include <memory>
2
3int main() {
4  auto FrodoPointer {
5    std::make_shared<Character>("Gandalf")
6  };
7}
8

Using Shared Pointers

In most ways, shared pointers can be used in exactly the same way as unique pointers. We can dereference them using the * and -> operators, and they automatically delete the object when appropriate:

1#include <iostream>
2#include <memory>
3using namespace std;
4
5int main() {
6  auto FrodoPointer { make_shared<Character>() };
7  cout << (*FrodoPointer).Name << endl;
8  cout << FrodoPointer->Name << endl;
9  cout << "Main Function Ending" << endl;
10}
11

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

We can access the raw pointer using get:

1#include <iostream>
2#include <memory>
3using namespace std;
4
5void LogName(const Character* Ptr) {
6  cout << Ptr->Name << endl;
7}
8
9int main() {
10  auto FrodoPointer { make_shared<Character>() };
11  LogName(FrodoPointer.get());
12  cout << "Main Function Ending" << endl;
13}
14

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

We can also transfer ownership using std::move:

1#include <iostream>
2#include <memory>
3using namespace std;
4
5void TakeOwnership(shared_ptr<Character> Ptr) {
6  cout << Ptr->Name << endl;
7}
8
9int main() {
10  auto FrodoPointer { make_shared<Character>() };
11  TakeOwnership(move(FrodoPointer));
12  cout << "Main Function Ending" << endl;
13}
14

As before with unique pointers, note how Frodo is now deleted at the end of the TakeOwnership function, rather than at the end of main

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

We can also reset :

1#include <iostream>
2#include <memory>
3
4int main() {
5  using namespace std;
6  auto Pointer { make_shared<Character>() };
7  Pointer.reset();
8  cout << "Main Function Ending" << endl;
9}
10

1Creating Frodo
2Deleting Frodo
3Main Function Ending
4

If the pointer we called reset on was the only shared pointer that owned the resource, the resource will be deleted. More information on how ownership can be shared is coming later in this lesson.

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

1int main() {
2  using namespace std;
3  auto Pointer { make_shared<Character>("Frodo") };
4  Pointer.reset(new Character {"Gandalf"});
5  cout << "Main Function Ending" << endl;
6}
7

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

And finally, we still have access to swap:

1#include <iostream>
2#include <memory>
3
4int main() {
5  using namespace std;
6  auto Pointer1 { make_shared<Character>("Frodo") };
7  auto Pointer2 { make_shared<Character>("Gandalf") };
8
9  cout << "1: " << Pointer1->Name << endl;
10  cout << "2: " << Pointer2->Name << endl;
11  
12  Pointer1.swap(Pointer2);
13
14  cout << "1: " << Pointer1->Name << endl;
15  cout << "2: " << Pointer2->Name << endl;
16}
17

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

Unlike unique pointers, shared pointers do not have a release function.

Sharing Shared Pointers

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:

1auto Pointer1 { std::make_shared<Character>() };
2auto Pointer2 { Pointer1 };
3

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:

1auto Pointer { make_shared<Character>() };
2SomeFunction(Pointer);
3SomeObject.SomeVariable = Pointer;
4

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.

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

1#include <iostream>
2#include <memory>
3
4using namespace std;
5
6class Party {
7public:
8  shared_ptr<Character> Member;
9};
10
11int main() {
12  auto Frodo { make_shared<Character>() };
13  auto Party1 { make_unique<Party>()};
14  auto Party2 { make_unique<Party>()};
15  
16  cout << "Frodo has "
17       << Frodo.use_count()
18       << " owner (the main function)"
19       << endl << endl;
20
21  cout << "Giving Party1 a copy" << endl;
22  Party1->Member = Frodo;
23  cout << "Frodo has "
24       << Frodo.use_count()
25       << " owners (main and Party1)"
26       << endl << endl;
27
28  cout << "Moving main's ownership to Party2" << endl;
29  Party2->Member = move(Frodo);
30  cout << "Frodo has "
31       << Party1->Member.use_count()
32       << " owners (Party1 and Party2)"
33       << endl << endl;
34
35  cout << "Deleting Party2" << endl;
36  Party2.reset();
37  
38  cout << "Frodo has "
39       << Party1->Member.use_count()
40       << " owner left (Party1)"
41       << endl << endl;
42
43  cout << "Deleting Party1"
44       << endl
45       << "Frodo will have no owners left so "
46       << "he will be automatically deleted"
47       << endl << endl;
48  Party1.reset();
49  
50  cout << "Main function ending" << endl;
51}
52

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
10Deleting Party2
11Frodo has 1 owner left (Party1)
12
13Deleting Party1
14Frodo will have no owners left so he will be automatically deleted
15
16Deleting Frodo
17Main function ending
18

Common Mistake: Not Copying Shared Pointers

By far, the most common mistake people make with shared pointers is not copying them when they intend to.

For example, the following code is not copying the shared pointer. Rather, it is creating a new shared pointer, from a raw pointer:

1int main() {
2  auto Pointer1 { make_shared<Character>() };
3  shared_ptr<Character> Pointer2 { Pointer1.get() };
4}
5

The mechanism that enables shared pointers to be “connected” is predicated on the copy operator. Therefore, for a new shared pointer to be connected to the existing set of pointers, it needs to be copied from one of the pointers in that set.

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 as another shared pointer:

1int x { 42 };
2std::shared_ptr<int> Pointer1 { &x };
3std::shared_ptr<int> Pointer2 { &x };
4std::cout "Owners: " << Pointer1.use_count();
5

1Owners: 1
2

Therefore, when we want to share ownership of an object, we should ensure we are triggering the copy constructor of the shared pointer.

1int x { 42 };
2std::shared_ptr<int> Pointer1 { &x };
3std::shared_ptr<int> Pointer2 { Pointer1 };
4std::cout "Owners: " << Pointer1.use_count();
5

1Owners: 2
2

Shared Pointer Casting

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

The only difference is, for shared pointers, we instead use std::dynamic_pointer_cast and std::static_pointer_cast, available from including <memory>

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

C++ Static Casting with Pointers (std::static_cast)

Learn how we can "downcast" our pointers to let us access functions in derived object types.

C++ Dynamic Casting (std::dynamic_cast)

An introduction to dynamic casting of pointers in C++ with examples using std::dynamic_cast

An example of using std::dynamic_pointer_cast being used with a std::shared_ptr is below:

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

1It's a monster!
2It's not a monster!
3

Shared Pointer Aliasing

Shared pointers have an interesting feature where the object they are sharing ownership over need not be the same as the object they are pointing at. This is typically referred to as aliasing.

It can be done by passing a pointer as the second argument to the shared_ptr constructor:

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

1Number Pointed At: 2
2

Care should be used when doing this, as it can create a memory management setup that is very confusing.

The simplest and 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 from under us:

1int main() {
2  auto Frodo { make_shared<Character>() };
3  shared_ptr<string> Name { Frodo, &Frodo->Name };
4
5  cout << "Name: " << *Name << endl;
6  cout << "Owners: " << Name.use_count() << endl;
7}
8

1Name: Frodo
2Owners: 2
3