Copy constructor (C++)

An object can be initialized by any one of the following ways.

a. Through declaration

Object b = a; // translates as Object::Object(const Object&) (invoke copy constructor)

b. Through function arguments

type function(Object a);

c. Through function return value

Object a = function();

The copy constructor is used only for initializations, and does not apply to assignments where the assignment operator is used instead.

The implicit copy constructor of a class calls base copy constructors and copies its members by means appropriate to their type. If it is a class type, the copy constructor is called. If it is a scalar type, the built-in assignment operator is used. Finally, if it is an array, each element is copied in the manner appropriate to its type.[3]

By using a user-defined copy constructor the programmer can define the behavior to be performed when an object is copied.

Consider the following example:

#include <iostream>

class Person {
 public:
  explicit Person(int age) : age(age) {}

  int age;
};

int main() {
  Person timmy(10);
  Person sally(15);

  Person timmy_clone = timmy;
  std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age
            << std::endl;
  timmy.age = 23;
  std::cout << timmy.age << " " << sally.age << " " << timmy_clone.age
            << std::endl;
}

Output

10 15 10
23 15 10

As expected, timmy has been copied to the new object, timmy_clone. While timmy's age was changed, timmy_clone's age remained the same. This is because they are totally different objects.

The compiler has generated a copy constructor for us, and it could be written like this:

Person(const Person& other) 
    : age(other.age)  // Calls the copy constructor of the age.
{
}

So, when do we really need a user-defined copy constructor? The next section will explore that question.

Consider a very simple dynamic array class like the following:

#include <iostream>

class Array {
 public:
  explicit Array(int size) : size(size), data(new int[size]) {}

  ~Array() {
    if (data != nullptr) {
      delete[] data;
    }
  }

  int size;
  int* data;
};

int main() {
  Array first(20);
  first.data[0] = 25;

  {
    Array copy = first;
    std::cout << first.data[0] << " " << copy.data[0] << std::endl;
  }  // (1)

  first.data[0] = 10;  // (2)
}

Output

25 25
Segmentation fault

Since we did not specify a copy constructor, the compiler generated one for us. The generated constructor would look something like:

Array(const Array& other)
  : size(other.size), data(other.data) {}

The problem with this constructor is that it performs a shallow copy of the data pointer. It only copies the address of the original data member; this means they both share a pointer to the same chunk of memory, which is not what we want. When the program reaches line (1), copy's destructor gets called (because objects on the stack are destroyed automatically when their scope ends). Array's destructor deletes the data array of the original, therefore when it deleted copy's data, because they share the same pointer, it also deleted first's data. Line (2) now accesses invalid data and writes to it. This produces a segmentation fault.

If we write our own copy constructor that performs a deep copy then this problem goes away.

// for std::copy
#include <algorithm>

Array(const Array& other)
    : size(other.size), data(new int[other.size]) {
  std::copy(other.data, other.data + other.size, data); 
}

Here, we are creating a new int array and copying the contents to it. Now, other's destructor deletes only its data, and not first's data. Line (2) will not produce a segmentation fault anymore.

Instead of doing a deep copy right away, there are some optimization strategies that can be used. These allow you to safely share the same data between several objects, thus saving space. The copy-on-write strategy makes a copy of the data only when it is written to. Reference counting keeps the count of how many objects are referencing the data, and will delete it only when this count reaches zero (e.g. boost::shared_ptr).

Contrary to expectations, a template copy constructor is not a user-defined copy constructor. Thus it is not enough to just have:

template <typename A> Array::Array(A const& other)
    : size(other.size()), data(new int[other.size()]) {
  std::copy(other.begin(), other.end(), data);
}

(Note that the type of A can be Array.) A user-defined, non-template copy constructor must also be provided for construction of Array from Array.