11 KiB
[class.copy.ctor]
11 Classes [class]
11.4 Class members [class.mem]
11.4.5 Constructors [class.ctor]
11.4.5.3 Copy/move constructors [class.copy.ctor]
A non-template constructor for classX is a copy constructor if its first parameter is of typeX&,const X&,volatile X& orconst volatile X&, and either there are no other parameters or else all other parameters have default arguments ([dcl.fct.default]).
[Example 1:
X::X(const X&) andX::X(X&,int=1) are copy constructors.
struct X { X(int); X(const X&, int = 1);}; X a(1); // calls X(int); X b(a, 0); // calls X(const X&, int); X c = b; // calls X(const X&, int); â end example]
A non-template constructor for class X is a move constructor if its first parameter is of type X&&, const X&&,volatile X&&, or const volatile X&&, and either there are no other parameters or else all other parameters have default arguments ([dcl.fct.default]).
[Example 2:
Y::Y(Y&&) is a move constructor.
struct Y { Y(const Y&); Y(Y&&);};extern Y f(int); Y d(f(1)); // calls Y(Y&&) Y e = d; // calls Y(const Y&) â end example]
[Note 1:
All forms of copy/move constructor can be declared for a class.
[Example 3: struct X { X(const X&); X(X&); // OK X(X&&); X(const X&&); // OK, but possibly not sensible}; â end example]
â end note]
[Note 2:
If a classX only has a copy constructor with a parameter of typeX&, an initializer of typeconstX orvolatileX cannot initialize an object of typecv X.
[Example 4: struct X { X(); // default constructor X(X&); // copy constructor with a non-const parameter};const X cx; X x = cx; // error: X::X(X&) cannot copy cx into x â end example]
â end note]
A declaration of a constructor for a classX is ill-formed if its first parameter is of typecv X and either there are no other parameters or else all other parameters have default arguments.
A member function template is never instantiated to produce such a constructor signature.
[Example 5: struct S {template S(T); S();};
S g;
void h() { S a(g); // does not instantiate the member template to produce S::S(S);// uses the implicitly declared copy constructor} â end example]
If the class definition does not explicitly declare a copy constructor, a non-explicit one is declared implicitly.
If the class definition declares a move constructor or move assignment operator, the implicitly declared copy constructor is defined as deleted; otherwise, it is defaulted ([dcl.fct.def]).
The latter case is deprecated if the class has a user-declared copy assignment operator or a user-declared destructor ([depr.impldec]).
The implicitly-declared copy constructor for a classX will have the formX::X(const X&) if each potentially constructed subobject of a class typeM (or array thereof) has a copy constructor whose first parameter is of typeconstM& orconstvolatileM&.89
Otherwise, the implicitly-declared copy constructor will have the formX::X(X&)
If the definition of a class X does not explicitly declare a move constructor, a non-explicit one will be implicitly declared as defaulted if and only if
X does not have a user-declared copy constructor,
X does not have a user-declared copy assignment operator,
X does not have a user-declared move assignment operator, and
X does not have a user-declared destructor.
[Note 3:
When the move constructor is not implicitly declared or explicitly supplied, expressions that otherwise would have invoked the move constructor might instead invoke a copy constructor.
â end note]
The implicitly-declared move constructor for class X will have the formX::X(X&&)
An implicitly-declared copy/move constructor is an inline public member of its class.
A defaulted copy/move constructor for a class X is defined as deleted ([dcl.fct.def.delete]) if X has:
a potentially constructed subobject of type M (or possibly multidimensional array thereof) for which overload resolution ([over.match]), as applied to find M's corresponding constructor, either does not result in a usable candidate ([over.match.general]) or, in the case of a variant member, selects a non-trivial function,
any potentially constructed subobject of class type M (or possibly multidimensional array thereof) where M has a destructor that is deleted or inaccessible from the defaulted constructor, or,
for the copy constructor, a non-static data member of rvalue reference type.
[Note 4:
A defaulted move constructor that is defined as deleted is ignored by overload resolution ([over.match], [over.over]).
Such a constructor would otherwise interfere with initialization from an rvalue which can use the copy constructor instead.
â end note]
A copy/move constructor for classX is trivial if it is not user-provided and if
classX has no virtual functions ([class.virtual]) and no virtual base classes ([class.mi]), and
the constructor selected to copy/move each direct base class subobject is trivial, and
for each non-static data member ofX that is of class type (or array thereof), the constructor selected to copy/move that member is trivial;
otherwise the copy/move constructor isnon-trivial.
[Note 5:
The copy/move constructor is implicitly defined even if the implementation elided its odr-use ([basic.def.odr], [class.temporary]).
â end note]
If an implicitly-defined ([dcl.fct.def.default]) constructor would be constexpr-suitable ([dcl.constexpr]), the implicitly-defined constructor is constexpr.
Before the defaulted copy/move constructor for a class is implicitly defined, all non-user-provided copy/move constructors for its potentially constructed subobjects are implicitly defined.
[Note 6:
An implicitly-declared copy/move constructor has an implied exception specification ([except.spec]).
â end note]
The implicitly-defined copy/move constructor for a non-union classX performs a memberwise copy/move of its bases and members.
[Note 7:
Default member initializers of non-static data members are ignored.
â end note]
The order of initialization is the same as the order of initialization of bases and members in a user-defined constructor (see [class.base.init]).
Let x be either the parameter of the constructor or, for the move constructor, an xvalue referring to the parameter.
Each base or non-static data member is copied/moved in the manner appropriate to its type:
if the member is an array, each element is direct-initialized with the corresponding subobject of x;
if a member m has rvalue reference type T&&, it is direct-initialized withstatic_cast<T&&>(x.m);
otherwise, the base or member is direct-initialized with the corresponding base or member of x.
Virtual base class subobjects shall be initialized only once by the implicitly-defined copy/move constructor (see [class.base.init]).
The implicitly-defined copy/move constructor for a unionX copies the object representation ([basic.types.general]) of X.
For each object nested within ([intro.object]) the object that is the source of the copy, a corresponding object o nested within the destination is identified (if the object is a subobject) or created (otherwise), and the lifetime of o begins before the copy is performed.
This implies that the reference parameter of the implicitly-declared copy constructor cannot bind to avolatile lvalue; see [diff.class].