[class.copy.ctor] - C++17 → C++20

Files changed (1) hide show

tmp/tmpe_zuup8p/{from.md → to.md} +37 -34

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

@@ -1,11 +1,11 @@
-### 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&)`
@@ -24,11 +24,11 @@ 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.
@@ -65,11 +65,11 @@ struct X {
 [*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 {
@@ -83,14 +83,14 @@ 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 {
@@ -110,24 +110,24 @@ void h() {
 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
 X::X(const X&)
 ```
 if each potentially constructed subobject of a class type `M` (or array
 thereof) has a copy constructor whose first parameter is of type `const`
-`M&` or `const` `volatile` `M&`.[^4] Otherwise, the implicitly-declared
 copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
@@ -150,64 +150,63 @@ form
 ``` cpp
 X::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 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
@@ -229,7 +228,11 @@ to its type:
 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`.

+#### 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&)`
 — *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.
 [*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 cv `X`.
 [*Example 4*:
 ``` cpp
 struct X {
 — *end example*]
 — *end note*]
 A declaration of a constructor for a class `X` is ill-formed if its
+first parameter is of type cv `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 {
 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 [[depr.impldec]].
 The implicitly-declared copy constructor for a class `X` will have the
 form
 ``` cpp
 X::X(const X&)
 ```
 if each potentially constructed subobject of a class type `M` (or array
 thereof) has a copy constructor whose first parameter is of type `const`
+`M&` or `const` `volatile` `M&`.[^3] Otherwise, the implicitly-declared
 copy constructor will have the form
 ``` cpp
 X::X(X&)
 ```
 ``` cpp
 X::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 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,
+- a variant member whose corresponding constructor as selected by
+  overload resolution is non-trivial,
 - 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.
+[*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 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* when it is odr-used [[basic.def.odr]], when it is
+needed for constant evaluation [[expr.const]], 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 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 class `X`
 performs a memberwise copy/move of its bases and members.
 [*Note 7*: Default member initializers of non-static data members are
 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`. 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.

Diff to HTML by rtfpessoa