In this lesson, we'll explore how objects are copied in more depth. There are two scenarios where our objects get copied. The first is when a new object is created by passing an existing object of the same type to the constructor:

1struct Weapon{/*...*/};
2
3int main() {
4  Weapon SwordA;
5  
6  // Create SwordB by copying SwordA
7  Weapon SwordB{SwordA};
8}

This copying process also happens when we pass an argument by value to a function. The function parameter is created by copying the object provided as the corresponding argument:

1struct Weapon{/*...*/};
2
3void SomeFunction(Weapon W) {/*...*/}
4
5int main() {
6  Weapon Sword;
7  
8  // Create the W parameter by copying Sword
9  SomeFunction(Sword);
10}

The second scenario is when an existing object is provided as the right operand to the = operator. In the following example, we're expecting an existing SwordA to be updated by copying values from SwordB:

1struct Weapon{/*...*/};
2
3int main() {
4  Weapon SwordA;
5  Weapon SwordB;
6  
7  // Update SwordA by copying values from SwordB
8  SwordA = SwordB;
9}

As we've noticed, C++ supports these behaviors by default, even when the objects we're copying use our custom types.

However, sometimes, those default implementations don't work exactly how we want. When we create a custom type, such as our Weapon example above, we sometimes need to control how instances of that type should be copied.

In this lesson, we'll explain why this is sometimes necessary, and learn how to take control over the copying process.

Subresources

The primary reason we need to override the default copying behavior is when our type is holding pointers to other types. These objects are often referred to as "resources" or "subresources" of our primary object.

Below, our Player type is holding a Sword resource in a pointer called Weapon:

1struct Sword{
2  std::string Name{"Iron Sword"};
3  int Damage{42};
4  float Durability{1.0};
5};
6
7struct Player {
8  Player(Sword* Weapon) : Weapon{Weapon} {};
9  Sword* Weapon{nullptr};
10};

When we copy a Player object, we should consider how subresources, such as the Weapon object, are handled as part of that process.

1int main() {
2  Sword Weapon;
3  Player A{&Weapon};
4  A.Weapon->Durability = 0.9;
5  
6  Player B{A};
7  B.Weapon; // What is this, exactly? 
8}

For example

Should B.Weapon be the same object as A.Weapon? That is, there is only a single weapon which both player A and B are sharing, meaning that A.Weapon and B.Weapon are both pointing to the same memory address.
Should B.Weapon be a new object, initialized with the same state (Name, Damage, and Durability) that A.Weapon had when it was copied?
Should B.Weapon be a new object, initialized with some default values, ignoring A.Weapon's state?

The default copying behavior assumes we want option 1, where both copies will then share the same resource. We'll explore what that actually means in the next section.

If we want our Player objects to copy their Weapon using option 2 or 3 instead, or something else entirely, then we need to intervene and provide that custom copying logic. This will be the focus of the rest of the lesson.

Let's start by examining how C++ behaves by default when we copy objects. We have a Player class that carries a Sword, which it stores as a pointer:

1struct Sword{};
2struct Player {
3  Player(Sword* Weapon) : Weapon{Weapon} {};
4  Sword* Weapon{nullptr};
5};
6
7int main() {
8  Sword IronSword;
9  Player PlayerOne{&IronSword};
10}

When we copy an object, we copy the pointers to its subresources, but not the objects to which they point. In the following example, we copy PlayerOne to create PlayerTwo.

Accordingly, PlayerOne.Weapon is copied to create PlayerTwo.Weapon. However, copying a pointer does not copy the object it was pointing at - it just means we now have two pointers pointing at the same underlying object. We can confirm this by checking that the PlayerOne.Weapon and PlayerTwo.Weapon pointers are equal:

1#include <iostream>
2
3struct Sword{};
4struct Player {
5  Player(Sword* Weapon) : Weapon{Weapon} {};
6  Sword* Weapon{nullptr};
7};
8
9int main() {
10  Sword IronSword;
11  Player PlayerOne{&IronSword};
12  Player PlayerTwo{PlayerOne};
13
14  if (PlayerOne.Weapon == PlayerTwo.Weapon) {
15    std::cout << "Players sharing same weapon";
16  }
17}

1Players sharing same weapon

We can imagine this situation as representing PlayerOne and PlayerTwo somehow wielding the exact same weapon. This is unlikely to be what we want for our game simulation, and could cause problems as we build out our program with more complex behaviors.

For example, if PlayerOne modifies their weapon in some way, those changes will affect PlayerTwo too. As we begin to rely more heavily on manual memory management, this could cause further resource management problems which we'll discuss in the next lesson.

Copy Constructors

To intervene and customize how objects of our type get copied, we need to define two particular functions on that type's class or struct:

The copy constructor
The copy assignment operator

As we've seen in the past, we can copy objects by default, even though we haven't been defining these functions. This is because the compiler provides default versions of these functions for the types we create. We can replace these default functions with our own custom implementations if we need to.

Let's see an example of adding a custom copy constructor to our Sword struct. Like any constructor, the name of the function matches the name of the class or struct. In the case of the copy constructor, the argument will be a constant reference to another object of that same type.

We'll call that other object Original, in this example:

1struct Sword {
2  Sword(const Sword& Original) {
3    std::cout << "Copying Sword\n";
4  }
5};

As usual, defining any constructor will delete the default constructor. If we want our type to continue to be constructible without any arguments, we now need to explicitly define that constructor.

If we want it to use the compiler-provided default implementation as before, we can use the = default syntax:

1struct Sword {
2  Sword() = default;
3  Sword(const Sword& Original) {
4    std::cout << "Copying Sword\n";
5  }
6};

Using the Copy Constructor

As we might expect, the copy constructor is invoked any time we construct a new object using an existing object of the same type. This includes when a function needs to create an object based on an argument passed to it by value:

1#include <iostream>
2
3struct Sword {
4  Sword() = default;
5  Sword(const Sword& Original) {
6    std::cout << "Copying Sword\n";
7  }
8};
9
10void SomeFunction(Sword) {}
11
12int main() {
13  Sword WeaponA;
14
15  // Constructing new Swords by copying WeaponA
16  Sword WeaponB{WeaponA}; // Copy 1
17  Sword WeaponC = WeaponA; // Copy 2
18
19  // Passing by value is copying, too
20  SomeFunction(WeaponA); // Copy 3
21}

1Copying Sword
2Copying Sword
3Copying Sword

Copying `Player` Objects

Let's return to our original example, and reexamine the problem of Player copies sharing the same Weapon. To start to solve this, we'll need to implement a custom copy constructor for our Player objects.

For now, we'll simply replicate the behavior of the default copy constructor where we copy the pointer to the Weapon, but not the Weapon itself. We'll also add some logging:

1#include <iostream>
2
3struct Sword {
4  Sword() = default;
5  Sword(const Sword& Original) {
6    std::cout << "Copying Sword\n";
7  }
8};
9
10struct Player {
11  Player(Sword* Weapon) : Weapon{Weapon} {}
12  Player(const Player& Original) {
13    Weapon = Original.Weapon;
14    std::cout << "Copying Player\n";
15  }
16
17  Sword* Weapon{nullptr};
18};
19
20int main() {
21  Sword IronSword;
22  Player PlayerOne{&IronSword};
23  Player PlayerTwo{PlayerOne};
24
25  if (PlayerOne.Weapon == PlayerTwo.Weapon) {
26    std::cout << "Players sharing same weapon";
27  }
28}

As we can see from the output, the copy constructor for Sword is not invoked, and both of our Player objects are left sharing the same weapon:

1Copying Player
2Players sharing same weapon

We'll finally fix this in the next section, but let's quickly review in this context.

Member Initializer Lists

As with any constructor, we can use a member initializer list with our copy constructor. This is the preferred way to set the initial values of member variables, so we should use it where possible:

1struct Player {
2  Player(Sword* Weapon) : Weapon{Weapon} {}
3  Player(const Player& Original)
4  : Weapon{Original.Weapon} {
5    std::cout << "Copying Player\n";
6  }
7
8  Sword* Weapon{nullptr};
9};

From a member initializer list, we can also invoke any other constructor. We already have a constructor that initializes the Weapon variable, so we can call that from the initializer list of our copy constructor:

1struct Player {
2  Player(Sword* Weapon) : Weapon{Weapon} {}
3  Player(const Player& Original)
4  : Player{Original.Weapon} {
5    std::cout << "Copying Player\n";
6  }
7
8  Sword* Weapon{nullptr};
9};

Deep Copying

Let's finally fix our root problem. Instead of having our copies share their subresources, we'll ensure every copy gets a complete copy of the subresources too.

This is easier and safer to do using smart pointers, so we'll switch our implementation to use a std::unique_ptr for now. We'll cover how to do this using raw pointers in the next lesson.

Remember, the function arguments passed to std::make_unique() are forwarded to the constructor of the type we're creating. We can invoke the copy constructor of that type by passing the object we want to copy.

This may include dereferencing a pointer to that object if necessary. In the following example, we default-construct WeaponA, and then copy-construct WeaponB by using WeaponA as the original:

1auto WeaponA{std::make_unique<Sword>()};
2auto WeaponB{std::make_unique<Sword>(*WeaponA)};

Let's use this technique in our Player example, where we retrieve the Weapon we want to copy by dereferencing the original player's Weapon:

1#include <iostream>
2
3struct Sword {
4  Sword() = default;
5  Sword(const Sword& Original) {
6    std::cout << "Copying Sword\n";
7  }
8};
9
10struct Player {
11  Player() : Weapon{std::make_unique<Sword>()} {}
12  Player(const Player& Original)
13  : Weapon{std::make_unique<Sword>(
14    *Original.Weapon
15  )} {
16    std::cout << "Copying Player\n";
17  }
18
19  std::unique_ptr<Sword> Weapon;
20};
21
22int main() {
23  Player PlayerOne;
24  Player PlayerTwo{PlayerOne};
25
26  if (PlayerOne.Weapon != PlayerTwo.Weapon) {
27    std::cout << "Players are NOT sharing "
28    "the same weapon";
29  }
30}

If we compile and run our program now, the output should confirm that the entire Sword object is being copied, rather than just a pointer to it. As a result, our Player objects are no longer sharing the same Sword - they each get their own:

1Copying Sword
2Copying Player
3Players are NOT sharing the same weapon

Copy Assignment Operator

There is another context in which objects are copied that we need to be mindful of when creating our types. This happens when the = operator is used to update an existing object using the values of some other object of the same type.

This is called the copy assignment operation:

1Player PlayerOne;
2Player PlayerTwo;
3
4// Use the copy assignment operator
5PlayerTwo = PlayerOne;

The default implementation of this operator behaves in the same way as the default copy constructor, shallow-copying values from the right operand to the left operand.

In this case, our type has been updated to use a std::unique_ptr, which cannot be copied by default. As such, we'll get a compilation error if we try to use the = operator in this way:

1#include <iostream>
2
3struct Sword {/*...*/};

1error C2280: 'Player& Player::operator =(const Player&)': attempting to reference a deleted function
2note: 'Player& Player::operator=(const Player&)': function was implicitly deleted because a data member invokes a deleted or inaccessible function
3note: 'std::unique_ptr<Sword>::operator=(const std::unique_ptr<Sword>&)': function was explicitly deleted

We can provide a custom implementation of this operator, using the same syntax we would when overloading any other operator. The error message above hints at what the function signature would be:

1Player& Player::operator=(const Player&)

That is, a function called operator= in the Player class that accepts a const reference to a Player object and returns a Player reference.

Therefore, the basic scaffolding for overloading this operator would look like this:

1#include <iostream>
2
3struct Sword {/*...*/};
10
11struct Player {
12  Player() {/*...*/};
14
15  Player(const Player& Original) {/*...*/};
21  
22  // Copy assignment operator
23  Player& operator=(const Player& Original) {
24    // Update this Player using data from Original
25    // ...
26    
27    // Then return a reference to it:
28    return *this;
29  }
30  
31  std::unique_ptr<Sword> Weapon;
32}
33
34int main() {/*...*/};

Our program will now compile, but our copy assignment operator isn't doing anything useful. Let's make it copy the Sword.

However, unlike with the copy constructor, the copy assignment operator isn't creating a new Player object. Rather, it is updating an existing Player, and this existing Player already has a Sword, which it stores as a std::unique_ptr called Weapon.

Depending on our specific requirements, there are two main options we have to deal with this.

Option 1: Update the Existing `Sword`

The first approach is that we can update the existing Sword to match the values from the Sword we want to copy.

That typically involves dereferencing the Weapon pointer to access the underlying Sword, and then using the = operator on that Sword:

1*Weapon = *Original.Weapon;

This calls the copy assignment operator on the underlying Sword type, passing the Sword held by the original character's Weapon pointer.

In this example, we've overloaded the copy assignment operator on Sword too, just to add some logging and confirm it's being used:

1#include <iostream>
2
3struct Sword {
4  Sword() = default;
5  Sword(const Sword& Original) {
6    std::cout << "Copying Sword by Constructor\n";
7  }
8  Sword& operator=(const Sword& Original) {
9    std::cout << "Copying Sword by Assignment\n";
10    return *this;
11  }
12};
13
14struct Player {
15  Player() {/*...*/};
17
18  Player(const Player& Original) {/*...*/};
24
25  // Copy assignment operator
26  Player& operator=(const Player& Original) {
27    *Weapon = *Original.Weapon;
28    return *this;
29  }
30
31  std::unique_ptr<Sword> Weapon;
32};

1Copying Sword by Assignment

Option 2: Replace the Existing `Sword`

Alternatively, we can delete the existing Sword and construct a new one using the Sword type's copy constructor.

As we saw within the Player copy constructor, we can pass the original player's Sword as the argument to std::make_unique<Sword>(). We can access their Sword by dereferencing the Weapon pointer that manages it:

1std::make_unique<Sword>(*Original.Weapon)

This will invoke the Sword type's copy constructor and return a std::unique_ptr that manages this new Sword.

The std::unique_ptr type has overloaded the = operator to make updates like this easier. It ensures the object it was previously managing is deleted, so updating a std::unique_ptr looks much the same as updating any other type:

1#include <iostream>
2
3struct Sword {
4  Sword() = default;
5  Sword(const Sword& Original) {
6    std::cout << "Copying Sword by Constructor\n";
7  }
8  Sword& operator=(const Sword& Original) {
9    std::cout << "Copying Sword by Assignment\n";
10    return *this;
11  }
12};
13
14struct Player {
15  Player() {/*...*/};
17
18  Player(const Player& Original) {/*...*/};
24
25  // Copy assignment operator
26  Player& operator=(const Player& Original) {
27    Weapon = std::make_unique<Sword>(
28      *Original.Weapon);
29    return *this;
30  }
31
32  std::unique_ptr<Sword> Weapon;
33};

1Copying Sword by Constructor

Note that the left operand of the = operator is different between these two options. In the first option, the left operand was *Weapon, whilst in option two, it is Weapon.

Weapon is the std::unique_ptr, whilst *Weapon dereferences that pointer to access the underlying Sword:

1// Option 1: Call the = operator on `Sword`
2*Weapon = *Original.Weapon
3
4// Option 2: Call the copy constructor on Sword,
5// followed by the = operator on `std::unique_ptr`
6Weapon = std::make_unique<Sword>(*Original.Weapon)

Copying an Object to Itself

When defining a copy assignment operator, there is an edge case we need to consider: that both operands are the same object. This is rare, but technically valid code:

1int main() {
2  Player PlayerOne;
3  PlayerOne = PlayerOne;
4}

We should ensure the logic in our operator remains valid in this scenario.

The most common approach is to have our operator start by comparing the this pointer to the memory address of the right operand. If these values are equal, both of our operands are the same.

When this is the case, our copy operator typically doesn't need to do anything, so we can return immediately:

1struct Player {
2  Player() {/*...*/};
4
5  Player(const Player& Original) {/*...*/};
10
11  // Copy assignment operator
12  Player& operator=(const Player& Original) {
13    if (&Original == this) {
14      return *this;
15    }
16
17    Weapon = std::make_unique<Sword>(*Original.Weapon);
18    return *this;
19  }
20
21  std::unique_ptr<Sword> Weapon;
22};

Recursive Copying

As we've seen before, if a type doesn't implement a copy constructor and copy assignment operator, the compiler generates them by default.

These default implementations simply iterate through all the member variables and call the copy constructor or copy assignment operator associated with their respective types. This process respects any custom implementations we've provided for those types.

For example, below we define a Party struct that contains Player objects. The Party class does not define a copy constructor or assignment operator, so it just uses the default implementations provided by the compiler.

However, when we copy Party objects, these default functions still respect the custom Player copy constructor and assignment operators that we defined:

1#include <iostream>
2
3struct Player {
4  Player() = default;
5  Player(const Player& Original) {
6    std::cout << "Copying Player by Constructor\n";
7  }
8
9  Player& operator=(const Player& Original) {
10    std::cout << "Copying Player by Assignment\n";
11    return *this;
12  }
13};
14
15struct Party {
16  Player PlayerOne;
17  // Other Players
18  // ...
19};
20
21int main() {
22  Party PartyOne;
23  Party PartyTwo{PartyOne};
24  PartyOne = PartyTwo;
25}

1Copying Player by Constructor
2Copying Player by Assignment

This means that, in general, objects that store subresources do not need to intervene to control how those subresources are copied, even if those subresources have non-standard requirements.

We simply implement those requirements by defining copy constructors and operators on the type that needs them. Objects that store instances of those types will then apply those behaviors automatically, with no additional effort required.

Preventing Copying

Sometimes, we don't want our types to support copying. This can be an intentional design choice like with std::unique_ptr, or perhaps supporting copying for our type would be a lot of work, and we'd rather not do it until we're sure we need that capability.

In either case, we should explicitly delete the default copy constructor and copy assignment operator. The syntax for deleting constructors and operators looks like this:

1struct Player {
2  Player() = default;
3  Player(const Player&) = delete;
4  Player& operator=(const Player&) = delete;
5};

Now, if someone tries to copy our object, they'll get a compiler error rather than a program that could have memory issues or other bugs:


1struct Player {/*...*/};
7
8int main() {
9  Player PlayerOne;
10  Player PlayerTwo{PlayerOne};
11  Player PlayerThree;
12  PlayerThree = PlayerOne;
13}

1error C2280: 'Player::Player(const Player&)': attempting to reference a deleted function
2note: 'Player::Player(const Player&)': function was explicitly deleted
3
4error C2280: 'Player& Player::operator=(const Player&)': attempting to reference a deleted function
5note: 'Player& Player::operator=(const Player&)': function was explicitly deleted

Preview: Sharing Ownership using `std::shared_ptr`

This lesson focused on scenarios where objects want unique ownership over their subobjects, but that is not always the case. In some scenarios, it's more appropriate for ownership of some resource to be shared among multiple objects.

For example, perhaps both of our players can share the same quest, with contributions from either player being tracked by the same underlying object.

The standard library provides another smart pointer for this scenario: std::shared_ptr. Whilst a std::unique_ptr automatically releases the resource it's managing once its unique owner is destroyed, a std::shared_ptr will release its object only when all of its shared owners are deleted.

To facilitate shared ownership, shared pointers can naturally be copied, and they provide utilities such as a use_count() method to return how many owners the pointer currently has:

1#include <iostream>
2#include <memory>
3
4struct Quest {};
5
6struct Player {
7  Player()
8  : CurrentQuest{std::make_shared<Quest>()} {}
9
10  std::shared_ptr<Quest> CurrentQuest;
11};
12
13int main() {
14  Player One;
15  std::cout << "Quest is being shared by "
16    << One.CurrentQuest.use_count() << " player";
17
18  // Create a copy
19  Player Two{One};
20  
21  if (One.CurrentQuest == Two.CurrentQuest) {
22    std::cout << "\nBoth players have the same quest";
23  }
24  std::cout << "\nQuest is being shared by "
25    << One.CurrentQuest.use_count() << " players";
26}

1Quest is being shared by 1 player
2Both players have the same quest
3Quest is being shared by 2 players

We cover std::shared_ptr in more detail in a dedicated lesson in the advanced course.

Summary

In this lesson, we've explored the intricacies of object copying in C++. We've covered copy constructors, copy assignment operators, and how to implement custom copying behavior. You've learned about shallow vs. deep copying, resource management, and how to prevent copying when necessary.

With this knowledge, you're now equipped to fully control object duplication in your programs. We'll build on these techniques and learn how to manually manage memory in the next lesson.

Copy Constructors and Operators

Subresources

Copy Constructors

Using the Copy Constructor

Copying `Player` Objects

Member Initializer Lists

Deep Copying

Copy Assignment Operator

Option 1: Update the Existing `Sword`

Option 2: Replace the Existing `Sword`

Copying an Object to Itself

Recursive Copying

Preventing Copying

Summary

Managing Memory Manually

Intro to C++ Programming

Questions & Answers

Copy Constructors and Operators

Subresources

Sharing Resources

Copy Constructors

Using the Copy Constructor

Copying Player Objects

Member Initializer Lists

Deep Copying

Copy Assignment Operator

Option 1: Update the Existing Sword

Option 2: Replace the Existing Sword

Copying an Object to Itself

Recursive Copying

Preventing Copying

Preview: Sharing Ownership using std::shared_ptr

Summary

Managing Memory Manually

Questions & Answers

Copying `Player` Objects

Option 1: Update the Existing `Sword`

Option 2: Replace the Existing `Sword`

Preview: Sharing Ownership using `std::shared_ptr`