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

Files changed (1) hide show

tmp/tmpaz9sxp4v/{from.md → to.md} +24 -28

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

@@ -44,11 +44,11 @@ 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 {
@@ -110,25 +110,26 @@ 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 [[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&)
 ```
@@ -141,11 +142,11 @@ if and only if
 - `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
@@ -154,24 +155,24 @@ 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:
@@ -184,22 +185,17 @@ user-provided and if:
   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.
@@ -228,11 +224,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`. 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.

 — *end example*]
 [*Note 1*:
+All forms of copy/move constructor can be declared for a class.
 [*Example 3*:
 ``` cpp
 struct X {
 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 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&)
 ```
 - `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
 form
 ``` cpp
 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 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:
   thereof), the constructor selected to copy/move that member is
   trivial;
 otherwise the copy/move constructor is *non-trivial*.
 [*Note 5*: The copy/move constructor is implicitly defined even if the
+implementation elided its odr-use
+[[term.odr.use]], [[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.
 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 [[term.object.representation]] 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