Copy Constructors and Operators

Copy Operations and Inheritance

How do copy constructors and assignment operators interact with inheritance?

Abstract art representing computer programming

Copy constructors and assignment operators interact with inheritance in C++ in several important ways. Understanding these interactions is crucial for correctly implementing copying behavior in class hierarchies.

Base Class Copying

When you create a copy constructor or copy assignment operator for a derived class, it's important to ensure that the base class part of the object is also correctly copied. This isn't done automatically.

For copy constructors, you need to explicitly call the base class copy constructor:

1#include <iostream>
2
3class Actor {
4public:
5  Actor() = default;
6  Actor(const Actor& other) {
7    std::cout << "Copying Actor\n";
8  }
9};
10
11class Player : public Actor {
12 public:
13  Player() = default;
14  Player(const Player& other)
15     // Explicitly copy base class part
16      : Actor(other) {  
17    std::cout << "Copying Player\n";
18  }
19};
20
21int main() {
22  Player p1;
23  Player p2(p1);
24}

1Copying Actor
2Copying Player

For copy assignment operators, you need to assign the base class part:

1class Player : public Actor {
2 public:
3  Player& operator=(const Player& other) {
4    // Assign base class part
5    Actor::operator=(other); 
6
7    // Copy Player-specific members
8    // ...
9
10    return *this;
11  }
12};

Virtual Copy Constructor Pattern

C++ doesn't support virtual copy constructors directly, but you can implement a similar pattern using a virtual clone method:

1#include <memory>
2
3class Weapon {
4public:
5  virtual ~Weapon() = default;
6  virtual std::unique_ptr<Weapon> clone() const
7    = 0;
8};
9
10class Sword : public Weapon {
11public:
12  std::unique_ptr<Weapon>
13    clone() const override {
14    return std::make_unique<Sword>(*this);
15  }
16};
17
18// Usage
19std::unique_ptr<Weapon> originalWeapon =
20  std::make_unique<Sword>();
21std::unique_ptr<Weapon> copiedWeapon =
22  originalWeapon->clone();

This pattern allows you to create copies of derived objects through base class pointers.

Slicing

Be cautious of object slicing when copying derived objects into base class objects:

1#include <iostream>
2
3class Weapon {
4public:
5  Weapon() = default;
6
7  Weapon(const Weapon&) {
8    std::cout << "Copying Weapon\n";
9  }
10};
11
12class Sword : public Weapon {
13public:
14  Sword() = default;
15
16  Sword(const Sword&) : Weapon() {
17    std::cout << "Copying Sword\n";
18  }
19};
20
21int main() {
22  Sword sword;
23
24  // Object slicing occurs here
25  Weapon weapon = sword; 
26}

1Copying Weapon

In this case, only the Weapon part of sword is copied, and any Sword-specific members are lost.

Understanding these interactions will help you implement robust copying behavior in your class hierarchies, avoiding common pitfalls and ensuring that objects are copied correctly at all levels of inheritance.

This Question is from the Lesson: