In the C++ programming language, a copy constructor is a special constructor for creating a new object as a copy of an existing object. Copy constructors are the standard way of copying objects in C++, as opposed to cloning, and have C++-specific nuances.

The first argument of such a constructor is a reference to an object of the same type as is being constructed (const or non-const), which might be followed by parameters of any type (all having default values).

Normally the compiler automatically creates a copy constructor for each class (known as an implicit copy constructor) but for special cases the programmer creates the copy constructor, known as a user-defined copy constructor. In such cases, the compiler does not create one. Hence, there is always one copy constructor that is either defined by the user or by the system.

A user-defined copy constructor is generally needed when an object owns pointers or non-shareable references, such as to a file, in which case a destructor and an assignment operator should also be written (see Rule of three).

Definition

Copying of objects is achieved by the use of a copy constructor and an assignment operator. A copy constructor has as its first parameter a (possibly const or volatile) reference to its own class type. It can have more arguments, but the rest must have default values associated with them.^[1] The following would be valid copy constructors for class X:

X(const X& copy_from_me);
X(X& copy_from_me);
X(volatile X& copy_from_me);
X(const volatile X& copy_from_me);
X(X& copy_from_me, int = 0);
X(const X& copy_from_me, double = 1.0, int = 42);
...

The first one should be used unless there is a good reason to use one of the others. One of the differences between the first and the second is that temporaries can be copied with the first. For example:

X a = X();     // valid given X(const X& copy_from_me) but not valid given X(X& copy_from_me)
               // because the second wants a non-const X&
               // to create a, the compiler first creates a temporary by invoking the default constructor
               // of X, then uses the copy constructor to initialize as a copy of that temporary. 
               // Temporary objects created during program execution are always of const type. So, const keyword is required.
               // For some compilers both versions actually work but this behaviour should not be relied 
               // upon because it's non-standard.

A similar difference applies when directly attempting to copy a const object:

const X a;
X b = a;       // valid given X(const X& copy_from_me) but not valid given X(X& copy_from_me)
               // because the second wants a non-const X&

The X& form of the copy constructor is used when it is necessary to modify the copied object. This is very rare but it can be seen used in the standard library's std::auto_ptr. A reference must be provided:

X a;
X b = a;       // valid if any of the copy constructors are defined
               // since a reference is being passed.

The following are invalid copy constructors because copy_from_me is not passed as reference (&) :

X(X copy_from_me);
X(const X copy_from_me);

because the call to those constructors would require a copy as well, which would result in an infinitely recursive call.

The following cases may result in a call to a copy constructor:

1. When an object is returned by value
2. When an object is passed (to a function) by value as an argument
3. When an object is thrown
4. When an object is caught by value
5. When an object is placed in a brace-enclosed initializer list

These cases are collectively called copy-initialization and are equivalent to:^[2] T x = a;

It is however, not guaranteed that a copy constructor will be called in these cases, because the C++ Standard allows the compiler to optimize the copy away in certain cases, one example being the return value optimization (sometimes referred to as RVO).

Operation

An object can be assigned value using one of the two techniques:

• Explicit assignment in an expression
• Initialization

Object a;
Object b;
a = b;       // translates as Object::operator=(const Object&), thus a.operator=(b) is called 
             // (invoke simple copy, not copy constructor!)

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

type function(Object a);

Object a = function();

Examples

These examples illustrate how copy constructors work and why they are sometimes required.

#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;
}

10 15 10
23 15 10

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

#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)
}

25 25
Segmentation fault

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

// 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); 
}

Bitwise copy constructor

There is no such thing as "bitwise copy constructor" in C++. However, the default generated copy constructor copies by invoking copy constructors on members, and for a raw pointer member this will copy the raw pointer (i.e. not a deep copy).

Logical copy constructor

It can be seen that in a logical copy constructor, a new dynamic member variable is created for the pointer along with copying the values.^[4]

A logical copy constructor makes a true copy of the structure as well as its dynamic structures. Logical copy constructors come into the picture mainly when there are pointers or complex objects within the object being copied.

Explicit copy constructor

An explicit copy constructor is one that is declared explicit by using the explicit keyword. For example:

explicit X(const X& copy_from_me);

It is used to prevent copying of objects at function calls or with the copy-initialization syntax.

See also

• Assignment operator in C++
• Object copying
• Rule of three (C++ programming)

References