Copy constructors
A copy constructor of class T is a non-template constructor whose first parameter is T&, const T&, volatile T&, or const volatile T&, and either there are no other parameters, or the rest of the parameters all have default values.
| Contents | 
[edit] Syntax
| class_name ( const class_name &) | (1) | ||||||||
| class_name ( const class_name &) = default; | (2) | ||||||||
| class_name ( const class_name &) = delete; | (3) | ||||||||
[edit] Explanation
- Typical declaration of a copy constructor.
- Forcing a copy constructor to be generated by the compiler.
- Avoiding implicit generation of the copy constructor.
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 ais of typeTandfis void f(T t);
-  function return: return a; inside a function such as T f(), where ais of typeT, which has no move constructor.
[edit] Implicitly-declared copy constructor
If no user-defined copy constructors are provided for a class type (struct, class, or union), 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 BofThas a copy constructor whose parameters are B or const B& or const volatile B&;
-  each non-static data member MofTof class type or array of class type has a copy constructor whose parameters are M or const M& or const volatile M&.
Otherwise, the implicitly-declared copy constructor is T::T(T&). (Note that 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&). If some user-defined copy constructors are present, the user may still force the generation of the implicitly declared copy constructor with the keyword  | (since C++11) | 
The implicitly-declared (or defaulted on its first declaration) copy constructor has an exception specification as described in dynamic exception specification (until C++17)exception specification (since C++17)
[edit] Deleted implicitly-declared copy constructor
| The implicitly-declared copy constructor for class Tis undefined if any of the following conditions are true: | (until C++11) | 
| The implicitly-declared or defaulted copy constructor for class Tis  defined as deleted if any of the following conditions are true: | (since C++11) | 
-  Thas non-static data members that cannot be copied (have deleted, inaccessible, or ambiguous copy constructors);
-  Thas direct or virtual base class that cannot be copied (has deleted, inaccessible, or ambiguous copy constructors);
-  Thas direct or virtual base class with a deleted or inaccessible destructor;
| 
 | (since C++11) | 
[edit] 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), and if it is defaulted, its signature is the same as implicitly-defined (until C++14);
-  Thas no virtual member functions;
-  Thas no virtual base classes;
-  the copy constructor selected for every direct base of Tis trivial;
-  the copy constructor selected for every non-static class type (or array of class type) member of Tis trivial;
A trivial copy constructor creates a bytewise copy of the object representation of the argument, and performs no other action. 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.
[edit] Implicitly-defined copy constructor
If the implicitly-declared copy constructor is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used. For union types, the implicitly-defined copy constructor copies the object representation (as by std::memmove). For non-union class types (class and struct), the constructor performs full member-wise copy of the object's bases and non-static members, in their initialization order, using direct initialization.
| The generation of the implicitly-defined copy constructor is deprecated if  | (since C++11) | 
[edit] Notes
In many situations, copy constructors are optimized out even if they would produce observable side-effects, see copy elision.
[edit] Example
struct A { int n; A(int n = 1) : n(n) { } A(const A& a) : n(a.n) { } // user-defined copy ctor }; struct B : A { // implicit default ctor B::B() // implicit copy ctor 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 ctor B b; B b2 = b; A a3 = b; // conversion to A& and copy ctor volatile A va(10); // A a4 = va; // compile error C c; // C c2 = c; // compile error }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior | 
|---|---|---|---|
| CWG 2171 | C++14 | X(X&) = default was non-trivial | made trivial | 
| CWG 496 | C++11 | structs with volatile members were trivially copyable | volatile members make copy non-trivial | 
| CWG 2094 | C++14 | volatile members make copy non-trivial | structs with volatile members are trivially copyable | 


