[class.copy] - C++14 → C++17

Files changed (1) hide show

tmp/tmpmrrl9h17/{from.md → to.md} +382 -125

tmp/tmpmrrl9h17/{from.md → to.md} RENAMED Viewed

@@ -5,15 +5,30 @@ A class object can be copied or moved in two ways: by initialization (
 [[expr.call]]) and for function value return ([[stmt.return]]); and by
 assignment ([[expr.ass]]). Conceptually, these two operations are
 implemented by a copy/move constructor ([[class.ctor]]) and copy/move
 assignment operator ([[over.ass]]).
 A non-template constructor for class `X` is a copy 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]]).
-`X::X(const X&)` and `X::X(X&,int=1)` are copy constructors.
 ``` cpp
 struct X {
   X(int);
   X(const X&, int = 1);
@@ -21,14 +36,19 @@ struct X {
 X a(1);             // calls X(int);
 X b(a, 0);          // calls X(const X&, int);
 X c = b;            // calls X(const X&, int);
 ```
 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]]).
 `Y::Y(Y&&)` is a move constructor.
 ``` cpp
 struct Y {
   Y(const Y&);
@@ -37,40 +57,60 @@ struct Y {
 extern Y f(int);
 Y d(f(1));          // calls Y(Y&&)
 Y e = d;            // calls Y(const Y&)
 ```
 All forms of copy/move constructor may be declared for a class.
 ``` cpp
 struct X {
   X(const X&);
   X(X&);            // OK
   X(X&&);
   X(const X&&);     // OK, but possibly not sensible
 };
 ```
 If a class `X` only has a copy constructor with a parameter of type
 `X&`, an initializer of type `const` `X` or `volatile` `X` cannot
 initialize an object of type (possibly cv-qualified) `X`.
 ``` cpp
 struct X {
   X();              // default constructor
-  X(X&);            // copy constructor with a nonconst parameter
 };
 const X cx;
 X x = cx;           // error: X::X(X&) cannot copy cx into x
 ```
 A declaration of a constructor for a class `X` is ill-formed if its
 first parameter is of type (optionally cv-qualified) `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.
 ``` cpp
 struct S {
   template<typename T> S(T);
   S();
 };
@@ -81,17 +121,19 @@ void h() {
   S a(g);           // does not instantiate the member template to produce S::S<S>(S);
                     // uses the implicitly declared copy constructor
 }
 ```
 If the class definition does not explicitly declare a copy constructor,
-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 defined as
-defaulted ([[dcl.fct.def]]). The latter case is deprecated if the class
-has a user-declared copy assignment operator or a user-declared
-destructor.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
@@ -106,20 +148,21 @@ copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 If the definition of a class `X` does not explicitly declare a move
-constructor, 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.
-When the move constructor is not implicitly declared or explicitly
-supplied, expressions that otherwise would have invoked the move
-constructor may instead invoke a copy constructor.
 The implicitly-declared move constructor for class `X` will have the
 form
 ``` cpp
@@ -132,64 +175,69 @@ is defined as deleted ([[dcl.fct.def.delete]]) if `X` has:
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
 - a potentially constructed subobject type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
-  as applied to `M`’s corresponding constructor, results in an ambiguity
-  or a function that is deleted or inaccessible from the defaulted
-  constructor,
 - any potentially constructed subobject of a type with 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.
 A defaulted move constructor that is defined as deleted is ignored by
-overload resolution ([[over.match]], [[over.over]]). A deleted move
-constructor would otherwise interfere with initialization from an rvalue
-which can use the copy constructor instead.
 A copy/move constructor for class `X` is trivial if it is not
-user-provided, its parameter-type-list is equivalent to the
-parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
-- class `X` has no non-static data members of volatile-qualified type,
-  and
 - the constructor selected to copy/move each direct base class subobject
   is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
 *implicitly defined* if it is odr-used ([[basic.def.odr]]) or when it
-is explicitly defaulted after its first declaration. The copy/move
-constructor is implicitly defined even if the implementation elided its
-odr-use ([[basic.def.odr]], [[class.temporary]]). If the
-implicitly-defined constructor would satisfy the requirements of a
-`constexpr` constructor ([[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 shall have been implicitly defined.
-An implicitly-declared copy/move constructor has an
-*exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move constructor for a non-union class `X`
 performs a memberwise copy/move of its bases and members.
-*brace-or-equal-initializer*s of non-static data members are ignored.
-See also the example in  [[class.base.init]]. 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 with `static_cast<T&&>(x.m)`;
@@ -200,19 +248,30 @@ 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 union `X` copies the
 object representation ([[basic.types]]) of `X`.
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
-`volatile` `X&`.[^5] An overloaded assignment operator must be declared
-to have only one parameter; see  [[over.ass]]. More than one form of
-copy assignment operator may be declared for a class. If a class `X`
-only has a copy assignment operator with a parameter of type `X&`, an
-expression of type const `X` cannot be assigned to an object of type
-`X`.
 ``` cpp
 struct X {
   X();
   X& operator=(X&);
@@ -222,10 +281,14 @@ X x;
 void f() {
   x = cx;           // error: X::operator=(X&) cannot assign cx into x
 }
 ```
 If the class definition does not explicitly declare a copy assignment
 operator, one is declared *implicitly*. If the class definition declares
 a move constructor or move assignment operator, the implicitly declared
 copy assignment operator is defined as deleted; otherwise, it is defined
 as defaulted ([[dcl.fct.def]]). The latter case is deprecated if the
@@ -253,24 +316,29 @@ the form
 X& X::operator=(X&)
 ```
 A user-declared move assignment operator `X::operator=` is a non-static
 non-template member function of class `X` with exactly one parameter of
-type `X&&`, `const X&&`, `volatile X&&`, or `const volatile X&&`. An
-overloaded assignment operator must be declared to have only one
-parameter; see  [[over.ass]]. \exitnote More than one form of move
-assignment operator may be declared for a class.
 If the definition of a class `X` does not explicitly declare a move
 assignment operator, 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 move constructor,
 - `X` does not have a user-declared copy assignment operator, and
 - `X` does not have a user-declared destructor.
 The class definition
 ``` cpp
 struct S {
   int a;
@@ -288,10 +356,12 @@ struct S {
   S& operator=(const S&) = default;
   S& operator=(S&&) = default;
 };
 ```
 The implicitly-declared move assignment operator for a class `X` will
 have the form
 ``` cpp
 X& X::operator=(X&&);
@@ -309,15 +379,16 @@ deleted if `X` has:
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
-- a potentially constructed subobject of class type `M` (or array
- thereof) that cannot be copied/moved because overload resolution (
-  [[over.match]]), as applied to `M`’s corresponding assignment
-  operator, results in an ambiguity or a function that is deleted or
-  inaccessible from the defaulted assignment operator.
 A defaulted move assignment operator that is defined as deleted is
 ignored by overload resolution ([[over.match]], [[over.over]]).
 Because a copy/move assignment operator is implicitly declared for a
@@ -331,17 +402,14 @@ declaration of such an operator and does not suppress the implicit
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
-user-provided, its parameter-type-list is equivalent to the
-parameter-type-list of an implicit declaration, and if
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
-- class `X` has no non-static data members of volatile-qualified type,
-  and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
@@ -355,20 +423,22 @@ assign to an object of its class type) or when it is explicitly
 defaulted after its first declaration. The implicitly-defined copy/move
 assignment operator is `constexpr` if
 - `X` is a literal type, and
 - the assignment operator selected to copy/move each direct base class
-  subobject is a `constexpr` function, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
-  a `constexpr` function.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
-been implicitly defined. An implicitly-declared copy/move assignment
-operator has an *exception-specification* ([[except.spec]]).
 The implicitly-defined copy/move assignment operator for a non-union
 class `X` performs memberwise copy/move assignment of its subobjects.
 The direct base classes of `X` are assigned first, in the order of their
 declaration in the *base-specifier-list*, and then the immediate
@@ -387,71 +457,79 @@ type:
   appropriate to the element type;
 - if the subobject is of scalar type, the built-in assignment operator
   is used.
 It is unspecified whether subobjects representing virtual base classes
-are assigned more than once by the implicitly-defined copy assignment
-operator.
 ``` cpp
 struct V { };
 struct A : virtual V { };
 struct B : virtual V { };
 struct C : B, A { };
 ```
 It is unspecified whether the virtual base class subobject `V` is
-assigned twice by the implicitly-defined copy assignment operator for
-`C`. This does not apply to move assignment, as a defaulted move
-assignment operator is deleted if the class has virtual bases.
 The implicitly-defined copy assignment operator for a union `X` copies
 the object representation ([[basic.types]]) of `X`.
-A program is ill-formed if the copy/move constructor or the copy/move
-assignment operator for an object is implicitly odr-used and the special
-member function is not accessible (Clause  [[class.access]]).
-Copying/moving one object into another using the copy/move constructor
-or the copy/move assignment operator does not change the layout or size
-of either object.
 When certain criteria are met, an implementation is allowed to omit the
 copy/move construction of a class object, even if the constructor
 selected for the copy/move operation and/or the destructor for the
 object have side effects. In such cases, the implementation treats the
 source and target of the omitted copy/move operation as simply two
-different ways of referring to the same object, and the destruction of
-that object occurs at the later of the times when the two objects would
-have been destroyed without the optimization.[^7] This elision of
-copy/move operations, called *copy elision*, is permitted in the
-following circumstances (which may be combined to eliminate multiple
-copies):
 - in a `return` statement in a function with a class return type, when
-  the expression is the name of a non-volatile automatic object (other
-  than a function or catch-clause parameter) with the same
- cv-unqualified type as the function return type, the copy/move
- operation can be omitted by constructing the automatic object directly
- into the function’s return value
-- in a , when the operand is the name of a non-volatile automatic object
-  (other than a function or catch-clause parameter) whose scope does not
- extend beyond the end of the innermost enclosing *try-block* (if there
- is one), the copy/move operation from the operand to the exception
- object ([[except.throw]]) can be omitted by constructing the
- automatic object directly into the exception object
-- when a temporary class object that has not been bound to a reference (
- [[class.temporary]]) would be copied/moved to a class object with the
-  same cv-unqualified type, the copy/move operation can be omitted by
- constructing the temporary object directly into the target of the
- omitted copy/move
-- when the of an exception handler (Clause  [[except]]) declares an
- object of the same type (except for cv-qualification) as the exception
- object ([[except.throw]]), the copy operation can be omitted by
- treating the as an alias for the exception object if the meaning of
- the program will be unchanged except for the execution of constructors
- and destructors for the object declared by the . There cannot be a
-  move from the exception object because it is always an lvalue.
 ``` cpp
 class Thing {
 public:
   Thing();
@@ -463,37 +541,67 @@ Thing f() {
   Thing t;
   return t;
 }
 Thing t2 = f();
 ```
-Here the criteria for elision can be combined to eliminate two calls to
-the copy constructor of class `Thing`: the copying of the local
-automatic object `t` into the temporary object for the return value of
-function `f()` and the copying of that temporary object into object
-`t2`. Effectively, the construction of the local object `t` can be
-viewed as directly initializing the global object `t2`, and that
-object’s destruction will occur at program exit. Adding a move
-constructor to `Thing` has the same effect, but it is the move
-construction from the temporary object to `t2` that is elided.
-When the criteria for elision of a copy/move operation are met, but not
-for an , and the object to be copied is designated by an lvalue, or when
-the *expression* in a `return` statement is a (possibly parenthesized)
-*id-expression* that names an object with automatic storage duration
-declared in the body or *parameter-declaration-clause* of the innermost
-enclosing function or *lambda-expression*, overload resolution to select
-the constructor for the copy is first performed as if the object were
-designated by an rvalue. If the first overload resolution fails or was
-not performed, or if the type of the first parameter of the selected
-constructor is not an rvalue reference to the object’s type (possibly
-cv-qualified), overload resolution is performed again, considering the
-object as an lvalue. This two-stage overload resolution must be
-performed regardless of whether copy elision will occur. It determines
-the constructor to be called if elision is not performed, and the
-selected constructor must be accessible even if the call is elided.
 ``` cpp
 class Thing {
 public:
   Thing();
@@ -508,8 +616,157 @@ Thing f(bool b) {
   if (b)
     throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
   return t;             // OK: Thing(Thing&&) used (or elided) to return t
 }
-Thing t2 = f(false); // OK: Thing(Thing&&) used (or elided) to construct t2
 ```

 [[expr.call]]) and for function value return ([[stmt.return]]); and by
 assignment ([[expr.ass]]). Conceptually, these two operations are
 implemented by a copy/move constructor ([[class.ctor]]) and copy/move
 assignment operator ([[over.ass]]).
+A program is ill-formed if the copy/move constructor or the copy/move
+assignment operator for an object is implicitly odr-used and the special
+member function is not accessible (Clause  [[class.access]]).
+[*Note 1*: Copying/moving one object into another using the copy/move
+constructor or the copy/move assignment operator does not change the
+layout or size of either object. — *end note*]
+### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
 A non-template constructor for class `X` is a copy 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 1*:
+`X::X(const X&)`
+and `X::X(X&,int=1)` are copy constructors.
 ``` cpp
 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.
 ``` cpp
 struct Y {
   Y(const 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 may be declared for a class.
+[*Example 3*:
 ``` cpp
 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 class `X` only has a copy constructor with a parameter of type
 `X&`, an initializer of type `const` `X` or `volatile` `X` cannot
 initialize an object of type (possibly cv-qualified) `X`.
+[*Example 4*:
 ``` cpp
 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 class `X` is ill-formed if its
 first parameter is of type (optionally cv-qualified) `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*:
 ``` cpp
 struct S {
   template<typename T> S(T);
   S();
 };
   S a(g);           // does not instantiate the member template to produce S::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
+defined as defaulted ([[dcl.fct.def]]). The latter case is deprecated
+if the class has a user-declared copy assignment operator or a
+user-declared destructor.
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 ``` cpp
 X::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 may instead invoke a copy constructor. — *end note*]
 The implicitly-declared move constructor for class `X` will have the
 form
 ``` cpp
 - a variant member with a non-trivial corresponding constructor and `X`
   is a union-like class,
 - a potentially constructed subobject type `M` (or array thereof) that
   cannot be copied/moved because overload resolution ([[over.match]]),
+  as applied to find `M`’s corresponding constructor, results in an
+ ambiguity or a function that is deleted or inaccessible from the
+ defaulted constructor,
 - any potentially constructed subobject of a type with 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.
 A defaulted move constructor that is defined as deleted is ignored by
+overload resolution ([[over.match]], [[over.over]]).
+[*Note 4*: A deleted move constructor would otherwise interfere with
+initialization from an rvalue which can use the copy constructor
+instead. — *end note*]
 A copy/move constructor for class `X` is trivial if it is not
+user-provided and if:
 - class `X` 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 of `X` that is of class type (or array
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 A copy/move constructor that is defaulted and not defined as deleted is
 *implicitly defined* if it is odr-used ([[basic.def.odr]]) or when it
+is explicitly defaulted after its first declaration.
+[*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 the implicitly-defined constructor would satisfy the requirements of
+a constexpr constructor ([[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 shall have been 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 class `X`
 performs a memberwise copy/move of its bases and members.
+[*Note 7*: Default member initializers of non-static data members are
+ignored. See also the example in  [[class.base.init]]. — *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 with `static_cast<T&&>(x.m)`;
 implicitly-defined copy/move constructor (see  [[class.base.init]]).
 The implicitly-defined copy/move constructor for a union `X` copies the
 object representation ([[basic.types]]) of `X`.
+### Copy/move assignment operator <a id="class.copy.assign">[[class.copy.assign]]</a>
 A user-declared *copy* assignment operator `X::operator=` is a
 non-static non-template member function of class `X` with exactly one
 parameter of type `X`, `X&`, `const` `X&`, `volatile` `X&` or `const`
+`volatile` `X&`.[^5]
+[*Note 1*: An overloaded assignment operator must be declared to have
+only one parameter; see  [[over.ass]]. — *end note*]
+[*Note 2*: More than one form of copy assignment operator may be
+declared for a class. — *end note*]
+[*Note 3*:
+If a class `X` only has a copy assignment operator with a parameter of
+type `X&`, an expression of type const `X` cannot be assigned to an
+object of type `X`.
+[*Example 1*:
 ``` cpp
 struct X {
   X();
   X& operator=(X&);
 void f() {
   x = cx;           // error: X::operator=(X&) cannot assign cx into x
 }
 ```
+— *end example*]
+— *end note*]
 If the class definition does not explicitly declare a copy assignment
 operator, one is declared *implicitly*. If the class definition declares
 a move constructor or move assignment operator, the implicitly declared
 copy assignment operator is defined as deleted; otherwise, it is defined
 as defaulted ([[dcl.fct.def]]). The latter case is deprecated if the
 X& X::operator=(X&)
 ```
 A user-declared move assignment operator `X::operator=` is a non-static
 non-template member function of class `X` with exactly one parameter of
+type `X&&`, `const X&&`, `volatile X&&`, or `const volatile X&&`.
+[*Note 4*: An overloaded assignment operator must be declared to have
+only one parameter; see  [[over.ass]]. — *end note*]
+[*Note 5*: More than one form of move assignment operator may be
+declared for a class. — *end note*]
 If the definition of a class `X` does not explicitly declare a move
 assignment operator, 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 move constructor,
 - `X` does not have a user-declared copy assignment operator, and
 - `X` does not have a user-declared destructor.
+[*Example 2*:
 The class definition
 ``` cpp
 struct S {
   int a;
   S& operator=(const S&) = default;
   S& operator=(S&&) = default;
 };
 ```
+— *end example*]
 The implicitly-declared move assignment operator for a class `X` will
 have the form
 ``` cpp
 X& X::operator=(X&&);
 - a variant member with a non-trivial corresponding assignment operator
   and `X` is a union-like class, or
 - a non-static data member of `const` non-class type (or array thereof),
   or
 - a non-static data member of reference type, or
+- a direct non-static data member of class type `M` (or array thereof)
+ or a direct base class `M` that cannot be copied/moved because
+ overload resolution ([[over.match]]), as applied to find `M`’s
+ corresponding assignment operator, results in an ambiguity or a
+ function that is deleted or inaccessible from the defaulted assignment
+  operator.
 A defaulted move assignment operator that is defined as deleted is
 ignored by overload resolution ([[over.match]], [[over.over]]).
 Because a copy/move assignment operator is implicitly declared for a
 declaration of the derived class operator; the operator introduced by
 the *using-declaration* is hidden by the implicitly-declared operator in
 the derived class.
 A copy/move assignment operator for class `X` is trivial if it is not
+user-provided and if:
 - class `X` has no virtual functions ([[class.virtual]]) and no virtual
   base classes ([[class.mi]]), and
 - the assignment operator selected to copy/move each direct base class
   subobject is trivial, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
   trivial;
 defaulted after its first declaration. The implicitly-defined copy/move
 assignment operator is `constexpr` if
 - `X` is a literal type, and
 - the assignment operator selected to copy/move each direct base class
+  subobject is a constexpr function, and
 - for each non-static data member of `X` that is of class type (or array
   thereof), the assignment operator selected to copy/move that member is
+  a constexpr function.
 Before the defaulted copy/move assignment operator for a class is
 implicitly defined, all non-user-provided copy/move assignment operators
 for its direct base classes and its non-static data members shall have
+been implicitly defined.
+[*Note 6*: An implicitly-declared copy/move assignment operator has an
+implied exception specification ([[except.spec]]). — *end note*]
 The implicitly-defined copy/move assignment operator for a non-union
 class `X` performs memberwise copy/move assignment of its subobjects.
 The direct base classes of `X` are assigned first, in the order of their
 declaration in the *base-specifier-list*, and then the immediate
   appropriate to the element type;
 - if the subobject is of scalar type, the built-in assignment operator
   is used.
 It is unspecified whether subobjects representing virtual base classes
+are assigned more than once by the implicitly-defined copy/move
+assignment operator.
+[*Example 3*:
 ``` cpp
 struct V { };
 struct A : virtual V { };
 struct B : virtual V { };
 struct C : B, A { };
 ```
 It is unspecified whether the virtual base class subobject `V` is
+assigned twice by the implicitly-defined copy/move assignment operator
+for `C`.
+— *end example*]
 The implicitly-defined copy assignment operator for a union `X` copies
 the object representation ([[basic.types]]) of `X`.
+### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
 When certain criteria are met, an implementation is allowed to omit the
 copy/move construction of a class object, even if the constructor
 selected for the copy/move operation and/or the destructor for the
 object have side effects. In such cases, the implementation treats the
 source and target of the omitted copy/move operation as simply two
+different ways of referring to the same object. If the first parameter
+of the selected constructor is an rvalue reference to the object’s type,
+the destruction of that object occurs when the target would have been
+destroyed; otherwise, the destruction occurs at the later of the times
+when the two objects would have been destroyed without the
+optimization.[^7] This elision of copy/move operations, called *copy
+elision*, is permitted in the following circumstances (which may be
+combined to eliminate multiple copies):
 - in a `return` statement in a function with a class return type, when
+  the *expression* is the name of a non-volatile automatic object (other
+  than a function parameter or a variable introduced by the
+ *exception-declaration* of a *handler* ([[except.handle]])) with the
+ same type (ignoring cv-qualification) as the function return type, the
+ copy/move operation can be omitted by constructing the automatic
+  object directly into the function call’s return object
+- in a *throw-expression* ([[expr.throw]]), when the operand is the
+ name of a non-volatile automatic object (other than a function or
+ catch-clause parameter) whose scope does not extend beyond the end of
+ the innermost enclosing *try-block* (if there is one), the copy/move
+ operation from the operand to the exception object ([[except.throw]])
+  can be omitted by constructing the automatic object directly into the
+ exception object
+- when the *exception-declaration* of an exception handler (Clause
+ [[except]]) declares an object of the same type (except for
+ cv-qualification) as the exception object ([[except.throw]]), the
+  copy operation can be omitted by treating the *exception-declaration*
+ as an alias for the exception object if the meaning of the program
+ will be unchanged except for the execution of constructors and
+ destructors for the object declared by the *exception-declaration*.
+ \[*Note 1*: There cannot be a move from the exception object because
+ it is always an lvalue. — *end note*]
+Copy elision is required where an expression is evaluated in a context
+requiring a constant expression ([[expr.const]]) and in constant
+initialization ([[basic.start.static]]).
+[*Note 2*: Copy elision might not be performed if the same expression
+is evaluated in another context. — *end note*]
+[*Example 1*:
 ``` cpp
 class Thing {
 public:
   Thing();
   Thing t;
   return t;
 }
 Thing t2 = f();
+struct A {
+  void *p;
+  constexpr A(): p(this) {}
+};
+constexpr A g() {
+  A a;
+  return a;
+}
+constexpr A a;          // well-formed, a.p points to a
+constexpr A b = g();    // well-formed, b.p points to b
+void g() {
+  A c = g();            // well-formed, c.p may point to c or to an ephemeral temporary
+}
 ```
+Here the criteria for elision can eliminate the copying of the local
+automatic object `t` into the result object for the function call `f()`,
+which is the global object `t2`. Effectively, the construction of the
+local object `t` can be viewed as directly initializing the global
+object `t2`, and that object’s destruction will occur at program exit.
+Adding a move constructor to `Thing` has the same effect, but it is the
+move construction from the local automatic object to `t2` that is
+elided.
+— *end example*]
+In the following copy-initialization contexts, a move operation might be
+used instead of a copy operation:
+- If the *expression* in a `return` statement ([[stmt.return]]) is a
+  (possibly parenthesized) *id-expression* that names an object with
+  automatic storage duration declared in the body or
+  *parameter-declaration-clause* of the innermost enclosing function or
+  *lambda-expression*, or
+- if the operand of a *throw-expression* ([[expr.throw]]) is the name
+  of a non-volatile automatic object (other than a function or
+  catch-clause parameter) whose scope does not extend beyond the end of
+ the innermost enclosing *try-block* (if there is one),
+overload resolution to select the constructor for the copy is first
+performed as if the object were designated by an rvalue. If the first
+overload resolution fails or was not performed, or if the type of the
+first parameter of the selected constructor is not an rvalue reference
+to the object’s type (possibly cv-qualified), overload resolution is
+performed again, considering the object as an lvalue.
+[*Note 3*: This two-stage overload resolution must be performed
+regardless of whether copy elision will occur. It determines the
+constructor to be called if elision is not performed, and the selected
+constructor must be accessible even if the call is
+elided. — *end note*]
+[*Example 2*:
 ``` cpp
 class Thing {
 public:
   Thing();
   if (b)
     throw t;            // OK: Thing(Thing&&) used (or elided) to throw t
   return t;             // OK: Thing(Thing&&) used (or elided) to return t
 }
+Thing t2 = f(false); // OK: no extra copy/move performed, t2 constructed by call to f
+struct Weird {
+  Weird();
+  Weird(Weird&);
+};
+Weird g() {
+  Weird w;
+  return w;             // OK: first overload resolution fails, second overload resolution selects Weird(Weird&)
+}
 ```
+— *end example*]
+<!-- Link reference definitions -->
+[basic.def.odr]: basic.md#basic.def.odr
+[basic.life]: basic.md#basic.life
+[basic.lookup]: basic.md#basic.lookup
+[basic.lval]: basic.md#basic.lval
+[basic.start.dynamic]: basic.md#basic.start.dynamic
+[basic.start.static]: basic.md#basic.start.static
+[basic.start.term]: basic.md#basic.start.term
+[basic.stc.auto]: basic.md#basic.stc.auto
+[basic.stc.dynamic]: basic.md#basic.stc.dynamic
+[basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[basic.stc.static]: basic.md#basic.stc.static
+[basic.stc.thread]: basic.md#basic.stc.thread
+[basic.types]: basic.md#basic.types
+[class]: class.md#class
+[class.abstract]: class.md#class.abstract
+[class.access]: class.md#class.access
+[class.base.init]: #class.base.init
+[class.cdtor]: #class.cdtor
+[class.conv]: #class.conv
+[class.conv.ctor]: #class.conv.ctor
+[class.conv.fct]: #class.conv.fct
+[class.copy]: #class.copy
+[class.copy.assign]: #class.copy.assign
+[class.copy.ctor]: #class.copy.ctor
+[class.copy.elision]: #class.copy.elision
+[class.ctor]: #class.ctor
+[class.dtor]: #class.dtor
+[class.expl.init]: #class.expl.init
+[class.free]: #class.free
+[class.friend]: class.md#class.friend
+[class.inhctor.init]: #class.inhctor.init
+[class.init]: #class.init
+[class.mem]: class.md#class.mem
+[class.member.lookup]: class.md#class.member.lookup
+[class.mfct]: class.md#class.mfct
+[class.mi]: class.md#class.mi
+[class.qual]: basic.md#class.qual
+[class.temporary]: #class.temporary
+[class.union]: class.md#class.union
+[class.union.anon]: class.md#class.union.anon
+[class.virtual]: class.md#class.virtual
+[conv]: conv.md#conv
+[conv.array]: conv.md#conv.array
+[conv.rval]: conv.md#conv.rval
+[dcl.array]: dcl.md#dcl.array
+[dcl.constexpr]: dcl.md#dcl.constexpr
+[dcl.fct]: dcl.md#dcl.fct
+[dcl.fct.def]: dcl.md#dcl.fct.def
+[dcl.fct.def.delete]: dcl.md#dcl.fct.def.delete
+[dcl.fct.default]: dcl.md#dcl.fct.default
+[dcl.fct.spec]: dcl.md#dcl.fct.spec
+[dcl.init]: dcl.md#dcl.init
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[dcl.init.list]: dcl.md#dcl.init.list
+[dcl.init.ref]: dcl.md#dcl.init.ref
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
+[dcl.type.cv]: dcl.md#dcl.type.cv
+[diff.special]: compatibility.md#diff.special
+[except]: except.md#except
+[except.ctor]: except.md#except.ctor
+[except.handle]: except.md#except.handle
+[except.spec]: except.md#except.spec
+[except.throw]: except.md#except.throw
+[expr]: expr.md#expr
+[expr.ass]: expr.md#expr.ass
+[expr.call]: expr.md#expr.call
+[expr.cast]: expr.md#expr.cast
+[expr.const]: expr.md#expr.const
+[expr.const.cast]: expr.md#expr.const.cast
+[expr.delete]: expr.md#expr.delete
+[expr.dynamic.cast]: expr.md#expr.dynamic.cast
+[expr.mptr.oper]: expr.md#expr.mptr.oper
+[expr.new]: expr.md#expr.new
+[expr.prim]: expr.md#expr.prim
+[expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
+[expr.pseudo]: expr.md#expr.pseudo
+[expr.ref]: expr.md#expr.ref
+[expr.sizeof]: expr.md#expr.sizeof
+[expr.static.cast]: expr.md#expr.static.cast
+[expr.sub]: expr.md#expr.sub
+[expr.throw]: expr.md#expr.throw
+[expr.type.conv]: expr.md#expr.type.conv
+[expr.typeid]: expr.md#expr.typeid
+[expr.unary.op]: expr.md#expr.unary.op
+[intro.execution]: intro.md#intro.execution
+[intro.object]: intro.md#intro.object
+[namespace.udecl]: dcl.md#namespace.udecl
+[over.ass]: over.md#over.ass
+[over.best.ics]: over.md#over.best.ics
+[over.ics.ref]: over.md#over.ics.ref
+[over.match]: over.md#over.match
+[over.match.best]: over.md#over.match.best
+[over.match.copy]: over.md#over.match.copy
+[over.over]: over.md#over.over
+[special]: #special
+[stmt.dcl]: stmt.md#stmt.dcl
+[stmt.return]: stmt.md#stmt.return
+[temp.dep.type]: temp.md#temp.dep.type
+[temp.variadic]: temp.md#temp.variadic
+[^1]: The same rules apply to initialization of an `initializer_list`
+    object ([[dcl.init.list]]) with its underlying temporary array.
+[^2]: These conversions are considered as standard conversions for the
+    purposes of overload resolution ([[over.best.ics]],
+    [[over.ics.ref]]) and therefore initialization ([[dcl.init]]) and
+    explicit casts ([[expr.static.cast]]). A conversion to `void` does
+    not invoke any conversion function ([[expr.static.cast]]). Even
+    though never directly called to perform a conversion, such
+    conversion functions can be declared and can potentially be reached
+    through a call to a virtual conversion function in a base class.
+[^3]: A similar provision is not needed for the array version of
+    `operator` `delete` because  [[expr.delete]] requires that in this
+    situation, the static type of the object to be deleted be the same
+    as its dynamic type.
+[^4]: This implies that the reference parameter of the
+    implicitly-declared copy constructor cannot bind to a `volatile`
+    lvalue; see  [[diff.special]].
+[^5]: Because a template assignment operator or an assignment operator
+    taking an rvalue reference parameter is never a copy assignment
+    operator, the presence of such an assignment operator does not
+    suppress the implicit declaration of a copy assignment operator.
+    Such assignment operators participate in overload resolution with
+    other assignment operators, including copy assignment operators,
+    and, if selected, will be used to assign an object.
+[^6]: This implies that the reference parameter of the
+    implicitly-declared copy assignment operator cannot bind to a
+    `volatile` lvalue; see  [[diff.special]].
+[^7]: Because only one object is destroyed instead of two, and one
+    copy/move constructor is not executed, there is still one object
+    destroyed for each one constructed.

Diff to HTML by rtfpessoa