Copy constructors

A copy constructor is a constructor which can be called with an argument of the same class type and copies the content of the argument without mutating the argument.

Syntax

Explanation

struct X
{
    X(X& other); // copy constructor
//  X(X other);  // Error: incorrect parameter type
};
 
union Y
{
    Y(Y& other, int num = 1); // copy constructor with multiple parameters
//  Y(Y& other, int num);     // Error: `num` has no default argument
};

The copy constructor is called whenever an object is initialized (by direct-initialization or copy-initialization) from another object of the same type (unless overload resolution selects a better match or the call is elided), which includes

• initialization: T a = b; or T a(b);, where b is of type T;
• function argument passing: f(a);, where a is of type T and f is void f(T t);
• function return: return a; inside a function such as T f(), where a is of type T, which has no move constructor.

Implicitly-declared copy constructor

If no user-defined copy constructors are provided for a class type, the compiler will always declare a copy constructor as a non-explicit inline public member of its class. This implicitly-declared copy constructor has the form T::T(const T&) if all of the following are true:

• each direct and virtual base B of T has a copy constructor whose parameters are of type const B& or const volatile B&;
• each non-static data member M of T of class type or array of class type has a copy constructor whose parameters are of type const M& or const volatile M&.

Otherwise, the implicitly-declared copy constructor is T::T(T&).

Due to these rules, the implicitly-declared copy constructor cannot bind to a volatile lvalue argument.

A class can have multiple copy constructors, e.g. both T::T(const T&) and T::T(T&).

The implicitly-declared (or defaulted on its first declaration) copy constructor has an exception specification as described in dynamic exception specification(until C++17)noexcept specification(since C++17).

Implicitly-defined copy constructor

If the implicitly-declared copy constructor is not deleted, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used or needed for constant evaluation(since C++11). For union types, the implicitly-defined copy constructor copies the object representation (as by std::memmove). For non-union class types, the constructor performs full member-wise copy of the object's bases and non-static members, in their initialization order, using direct initialization.

Deleted copy constructor

The implicitly-declared or explicitly-defaulted(since C++11) copy constructor for class T is undefined(until C++11)defined as deleted(since C++11) if any of the following conditions is satisfied:

• T has a potentially constructed subobject of class type M (or possibly multi-dimensional array thereof) such that
• M has a destructor that is deleted or(since C++11) inaccessible from the copy constructor, or
• the overload resolution as applied to find M's copy constructor
• does not result in a usable candidate, or
• in the case of the subobject being a variant member, selects a non-trivial function.

Trivial copy constructor

The copy constructor for class T is trivial if all of the following are true:

• it is not user-provided (that is, it is implicitly-defined or defaulted);
• T has no virtual member functions;
• T has no virtual base classes;
• the copy constructor selected for every direct base of T is trivial;
• the copy constructor selected for every non-static class type (or array of class type) member of T is trivial;

A trivial copy constructor for a non-union class effectively copies every scalar subobject (including, recursively, subobject of subobjects and so forth) of the argument and performs no other action. However, padding bytes need not be copied, and even the object representations of the copied subobjects need not be the same as long as their values are identical.

TriviallyCopyable objects can be copied by copying their object representations manually, e.g. with std::memmove. All data types compatible with the C language (POD types) are trivially copyable.

Eligible copy constructor

Triviality of eligible copy constructors determines whether the class is an implicit-lifetime type, and whether the class is a trivially copyable type.

Notes

In many situations, copy constructors are optimized out even if they would produce observable side-effects, see copy elision.

Example

struct A
{
    int n;
    A(int n = 1) : n(n) {}
    A(const A& a) : n(a.n) {} // user-defined copy constructor
};
 
struct B : A
{
    // implicit default constructor B::B()
    // implicit copy constructor B::B(const B&)
};
 
struct C : B
{
    C() : B() {}
private:
    C(const C&); // non-copyable, C++98 style
};
 
int main()
{
    A a1(7);
    A a2(a1); // calls the copy constructor
 
    B b;
    B b2 = b;
    A a3 = b; // conversion to A& and copy constructor
 
    volatile A va(10);
    // A a4 = va; // compile error
 
    C c;
    // C c2 = c; // compile error
}

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also

• converting constructor
• copy assignment
• copy elision
• default constructor
• destructor
• explicit
• initialization
  • aggregate initialization
  • constant initialization
  • copy initialization
  • default initialization
  • direct initialization
  • initializer list
  • list initialization
  • reference initialization
  • value initialization
  • zero initialization
• move assignment
• move constructor
• new