Copy constructors
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.
Syntax
class_name ( const class_name & ) | (1) | |
class_name ( const class_name & ) = default; | (2) | |
class_name ( const class_name & ) = delete; | (3) |
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;
orT a(b);
, where b is of typeT
; - function argument passing:
f(a);
, wherea
is of typeT
andf
isvoid f(T t)
; - function return:
return a;
inside a function such asT f()
, wherea
is of typeT
, which has no move constructor.
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
B
ofT
has a copy constructor whose parameters areB
orconst B&
orconst volatile B&
; - each non-static data member
M
ofT
of class type or array of class type has a copy constructor whose parameters areM
orconst M&
orconst 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 | (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).
Deleted implicitly-declared copy constructor
The implicitly-declared copy constructor for class T is undefined if any of the following conditions are true: | (until C++11) |
The implicitly-declared or defaulted copy constructor for class T is defined as deleted if any of the following conditions are true: | (since C++11) |
-
T
has non-static data members that cannot be copied (have deleted, inaccessible, or ambiguous copy constructors); -
T
has direct or virtual base class that cannot be copied (has deleted, inaccessible, or ambiguous copy constructors); -
T
has direct or virtual base class with a deleted or inaccessible destructor;
| (since C++11) |
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);
-
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 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.
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) |
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 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 }
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 |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/language/copy_constructor