A copy constructor is a
which can be called with an argument of the same class type and copies the content of the argument without mutating the argument.
Syntax
class-name(parameter-list);(1) class-name(parameter-list)function-body(2) class-name(single-parameter-list) = default;(3) (since C++11)class-name(parameter-list) = delete;(4) (since C++11)class-name::class-name(parameter-list)function-body(5) class-name::class-name(single-parameter-list) = default;(6) (since C++11)class-name- the class whose copy constructor is being declared parameter-list- a non-empty
satisfying all following conditions: given the class type as T, the first parameter is of type T&, constT&, volatileT& or constvolatileT&, and
either there are no other parameters, or all other parameters have
.
single-parameter-list- a
of only one parameter, which is of type T&, constT&, volatileT& or constvolatileT& and does not have a default argument function-body- the
of the copy constructor Explanation
1) Declaration of a copy constructor inside of class definition.
2-4) Definition of a copy constructor inside of class definition.
3) The copy constructor is explicitly-defaulted.
4) The copy constructor is deleted.
5,6) Definition of a copy constructor outside of class definition (the class must contain a declaration (1)).
6) The copy constructor is explicitly-defaulted.
structX{X(X&other);// copy constructor// X(X other); // Error: incorrect parameter type};unionY{Y(Y&other,intnum=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
(by
or
) from another object of the same type (unless
selects a better match or the call is
), which includes
initialization: Ta=b; or Ta(b);, where b is of type T;
function argument passing: f(a);, where a is of type T and f is voidf(Tt);
function return: returna; inside a function such as Tf(), where a is of type T, which has no
.
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-
inlinepublic member of its class. This implicitly-declared copy constructor has the form T::T(constT&) if all of the following are true:
each direct and virtual base B of T has a copy constructor whose parameters are of type constB& or constvolatileB&;
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 constM& or constvolatileM&.
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(constT&) and T::T(T&).
Even if some user-defined copy constructors are present, the user may still force the implicit copy constructor declaration with the keyword default.
(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)
(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
or
needed for constant evaluation
(since C++11). For union types, the implicitly-defined copy constructor copies the object representation (as by
). For non-union class types, the constructor performs full member-wise copy of the object's direct base subobjects and member subobjects, in their initialization order, using direct initialization. For each non-static data member of a reference type, the copy constructor binds the reference to the same object or function to which the source reference is bound.
If this satisfies the requirements of a
(until C++23)
(since C++23), the generated copy constructor is constexpr.
The generation of the implicitly-defined copy constructor is deprecated if T has a user-defined destructor or user-defined copy assignment operator.
(since C++11)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 non-static data member of rvalue reference type.
(since C++11)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
, 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.
objects can be copied by copying their object representations manually, e.g. with
. All data types compatible with the C language (POD types) are trivially copyable.
Eligible copy constructor
A copy constructor is eligible if it is either user-declared or both implicitly-declared and definable.
(until C++11)A copy constructor is eligible if it is not deleted.
(since C++11)
(until C++20)A copy constructor is eligible if all following conditions are satisfied:
It is not deleted.
Its
(if any) are satisfied.
No copy constructor whose associated constraints are satisfied is
.
(since C++20)Triviality of eligible copy constructors determines whether the class is an
, and whether the class is a
.
Notes
In many situations, copy constructors are optimized out even if they would produce observable side-effects, see
.
Example
structA{intn;A(intn=1):n(n){}A(constA&a):n(a.n){}// user-defined copy constructor};structB:A{// implicit default constructor B::B()// implicit copy constructor B::B(const B&)};structC:B{C():B(){}private:C(constC&);// non-copyable, C++98 style};intmain(){Aa1(7);Aa2(a1);// calls the copy constructorBb;Bb2=b;Aa3=b;// conversion to A& and copy constructorvolatileAva(10);// A a4 = va; // compile errorCc;// 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
C++98 the conditions where implicitly-declared copy constructors
are undefined did not consider multi-dimensional array types consider these types
C++11 volatile members make copy non-trivial (
) triviality not affected
C++11 X(X&)=default was non-trivial made trivial
C++20 a copy constructor was not eligible if there is
another copy constructor which is more constrained
but does not satisfy its associated constraints it can be eligible in this case See also