Copy constructors (C++ only)

The copy constructor lets you create a new object from an existing one by initialization. A copy constructor of a class A is a non-template constructor in which the first parameter is of type A&, const A&, volatile A&, or const volatile A&, and the rest of its parameters (if there are any) have default values.

If you do not declare a copy constructor for a class A, the compiler will implicitly declare one for you, which will be an inline public member.

#include <iostream>
using namespace std;

struct A {
  int i;
  A() : i(10) { }
};

struct B {
  int j;
  B() : j(20) {
    cout << "Constructor B(), j = " << j << endl;
  }

  B(B& arg) : j(arg.j) {
    cout << "Copy constructor B(B&), j = " << j << endl;
  }

  B(const B&, int val = 30) : j(val) {
    cout << "Copy constructor B(const B&, int), j = " << j << endl;
  }
};

struct C {
  C() { }
  C(C&) { }
};

int main() {
  A a;
  A a1(a);
  B b;
  const B b_const;
  B b1(b);
  B b2(b_const);
  const C c_const;
//  C c1(c_const);
}

Constructor B(), j = 20
Constructor B(), j = 20
Copy constructor B(B&), j = 20
Copy constructor B(const B&, int), j = 30

The statement A a1(a) creates a new object from a with an implicitly defined copy constructor. The statement B b1(b) creates a new object from b with the user-defined copy constructor B::B(B&). The statement B b2(b_const) creates a new object with the copy constructor B::B(const B&, int). The compiler would not allow the statement C c1(c_const) because a copy constructor that takes as its first parameter an object of type const C& has not been defined.

The implicitly declared copy constructor of a class A will have the form A::A(const A&) if the following are true:

• The direct and virtual bases of A have copy constructors whose first parameters have been qualified with const or const volatile
• The nonstatic class type or array of class type data members of A have copy constructors whose first parameters have been qualified with const or const volatile

If the above are not true for a class A, the compiler will implicitly declare a copy constructor with the form A::A(A&).

A program is ill-formed if it includes a class A whose copy constructor is implicitly defined or explicitly defaulted when one or more of the following conditions are true:

• Class A has a nonstatic data member of a type which has an inaccessible or ambiguous copy constructor.
• Class A is derived from a class which has an inaccessible or ambiguous copy constructor.

The compiler will implicitly define an implicitly declared or explicitly defaulted constructor of a class A if you initialize an object of type A or an object derived from class A.

An implicitly defined or explicitly defaulted copy constructor will copy the bases and members of an object in the same order that a constructor would initialize the bases and members of the object.

Note: You can declare copy constructors as explicitly defaulted functions or deleted functions. For more information, see Explicitly defaulted functions (C++11) and Deleted functions (C++11).