How to Implement a Copy Constructor in a Derived Class in C++

In object-oriented programming, a copy constructor is a special member function that initializes a new object as a copy of an existing object. In this article, we will learn how to implement a copy constructor in a derived class.

Implementing Copy Constructor in a Derived Class in C++

In C++, when we implement a constructor in an inherited class, we need to explicitly call the corresponding constructor of the base class also so that we can avoid implement same constructor logic again and again. Some thing happens with copy constructor.

To implement a copy constructor in a derived class in C++, we have to call the copy constructor of the base class too in the definition as shown in the below syntax

Syntax to Create a Copy Constructor in a Derived Class in C++

Derived(const Derived& other_Object) : Base(other_Object) {
    // Derived class copy constructor body
}

C++ Program to Implement a Copy Constructor in a Derived Class

The following program illustrates how we can implement a copy constructor in a derived class.

C++

// C++ Program to  illustrate how we can implement a copy
// constructor in a derived class
#include <iostream>
using namespace std;

// Base class
class Base {
private:
    int baseData;

public:
    Base(int data)
        : baseData(data)
    {
        cout << "Base constructor called with data: "
             << data << endl;
    }

    // Copy constructor
    Base(const Base& other)
        : baseData(other.baseData)
    {
        cout << "Base copy constructor called" << endl;
    }

    void display()
    {
        cout << "Base data: " << baseData << endl;
    }
};

// Derived class
class Derived : public Base {
private:
    int derivedData;

public:
    Derived(int baseData, int derivedData)
        : Base(baseData)
        , derivedData(derivedData)
    {
        cout << "Derived constructor called with data: "
             << derivedData << endl;
    }

    // defining the copy constructor of derived class and
    // calling the base class copy constructor too
    Derived(const Derived& other)
        : Base(other)
        , derivedData(other.derivedData)
    {
        cout << "Derived copy constructor called" << endl;
    }

    void display()
    {
        // Call base class's display function
        Base::display();
        cout << "Derived data: " << derivedData << endl;
    }
};

int main()
{
    Derived obj1(10, 20);
    // Copy constructor of derived class is called
    Derived obj2 = obj1;

    cout << "\nObject 1:" << endl;
    obj1.display();
    cout << "\nObject 2:" << endl;
    obj2.display();

    return 0;
}

Output

Base constructor called with data: 10
Derived constructor called with data: 20
Base copy constructor called
Derived copy constructor called
Object 1:
Base data: 10
Derived data: 20
Object 2:
Base data: 10
Derived data: 20

Time Complexity: O(1)
Auxiliary Space: O(1)