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

Files changed (1) hide show

tmp/tmpzuvi5shr/{from.md → to.md} +60 -67

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

@@ -1,29 +1,32 @@
 ### Constructors <a id="class.ctor">[[class.ctor]]</a>
-A *constructor* is introduced by a declaration whose *declarator* is a
-function declarator [[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
-- in a *member-declaration* that belongs to the *member-specification*
- of a class or class template but is not a friend declaration
-  [[class.friend]], the *id-expression* is the injected-class-name
- [[class.pre]] of the immediately-enclosing entity or
-- in a declaration at namespace scope or in a friend declaration, the
- *id-expression* is a *qualified-id* that names a constructor
-  [[class.qual]].
 Constructors do not have names. In a constructor declaration, each
 *decl-specifier* in the optional *decl-specifier-seq* shall be `friend`,
-`inline`, `constexpr`, or an *explicit-specifier*.
 [*Example 1*:
 ``` cpp
 struct S {
@@ -33,18 +36,17 @@ struct S {
 S::S() { }          // defines the constructor
 ```
 — *end example*]
-A constructor is used to initialize objects of its class type. Because
-constructors do not have names, they are never found during name lookup;
-however an explicit type conversion using the functional notation
-[[expr.type.conv]] will cause a constructor to be called to initialize
-an object.
-[*Note 1*: The syntax looks like an explicit call of the
-constructor. — *end note*]
 [*Example 2*:
 ``` cpp
 complex zz = complex(1,2.3);
@@ -71,15 +73,19 @@ during construction; see  [[class.base.init]] and
 A constructor can be invoked for a `const`, `volatile` or `const`
 `volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
 not applied on an object under construction. They come into effect when
 the constructor for the most derived object [[intro.object]] ends.
-A `return` statement in the body of a constructor shall not specify a
-return value. The address of a constructor shall not be taken.
 A constructor shall not be a coroutine.
 #### Default constructors <a id="class.default.ctor">[[class.default.ctor]]</a>
 A *default constructor* for a class `X` is a constructor of class `X`
 for which each parameter that is not a function parameter pack has a
 default argument (including the case of a constructor with no
@@ -127,42 +133,33 @@ A default constructor is *trivial* if it is not user-provided and if:
   type (or array thereof), each such class has a trivial default
   constructor.
 Otherwise, the default constructor is *non-trivial*.
-A default constructor that is defaulted and not defined as deleted is
-*implicitly defined* when it is odr-used [[basic.def.odr]] to create an
-object of its class type [[intro.object]], when it is needed for
-constant evaluation [[expr.const]], or when it is explicitly defaulted
-after its first declaration. The implicitly-defined default constructor
 performs the set of initializations of the class that would be performed
 by a user-written default constructor for that class with no
 *ctor-initializer* [[class.base.init]] and an empty
 *compound-statement*. If that user-written default constructor would be
 ill-formed, the program is ill-formed. If that user-written default
-constructor would satisfy the requirements of a constexpr constructor
-[[dcl.constexpr]], the implicitly-defined default constructor is
-`constexpr`. Before the defaulted default constructor for a class is
-implicitly defined, all the non-user-provided default constructors for
-its base classes and its non-static data members are implicitly defined.
 [*Note 1*: An implicitly-declared default constructor has an exception
 specification [[except.spec]]. An explicitly-defaulted definition might
 have an implicit exception specification, see
 [[dcl.fct.def]]. — *end note*]
-Default constructors are called implicitly to create class objects of
-static, thread, or automatic storage duration ([[basic.stc.static]],
-[[basic.stc.thread]], [[basic.stc.auto]]) defined without an initializer
-[[dcl.init]], are called to create class objects of dynamic storage
-duration [[basic.stc.dynamic]] created by a *new-expression* in which
-the *new-initializer* is omitted [[expr.new]], or are called when the
-explicit type conversion syntax [[expr.type.conv]] is used. A program is
-ill-formed if the default constructor for an object is implicitly used
-and the constructor is not accessible [[class.access]].
-[*Note 2*:  [[class.base.init]] describes the order in which
 constructors for base classes and non-static data members are called and
 describes how arguments can be specified for the calls to these
 constructors. — *end note*]
 #### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
@@ -211,11 +208,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 {
@@ -277,25 +274,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&)
 ```
@@ -308,11 +306,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
@@ -321,24 +319,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:
@@ -351,22 +349,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.
@@ -395,11 +388,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.

 ### Constructors <a id="class.ctor">[[class.ctor]]</a>
+#### General <a id="class.ctor.general">[[class.ctor.general]]</a>
+A *declarator* declares a *constructor* if it is a function declarator
+[[dcl.fct]] of the form
 ``` bnf
 ptr-declarator '(' parameter-declaration-clause ')' noexcept-specifierₒₚₜ attribute-specifier-seqₒₚₜ
 ```
 where the *ptr-declarator* consists solely of an *id-expression*, an
 optional *attribute-specifier-seq*, and optional surrounding
 parentheses, and the *id-expression* has one of the following forms:
+- in a friend declaration [[class.friend]], the *id-expression* is a
+ *qualified-id* that names a constructor [[class.qual]];
+- otherwise, in a *member-declaration* that belongs to the
+ *member-specification* of a class or class template, the
+  *id-expression* is the injected-class-name [[class.pre]] of the
+ immediately-enclosing entity;
+- otherwise, the *id-expression* is a *qualified-id* whose
+  *unqualified-id* is the injected-class-name of its lookup context.
 Constructors do not have names. In a constructor declaration, each
 *decl-specifier* in the optional *decl-specifier-seq* shall be `friend`,
+`inline`, `constexpr`, `consteval`, or an *explicit-specifier*.
 [*Example 1*:
 ``` cpp
 struct S {
 S::S() { }          // defines the constructor
 ```
 — *end example*]
+A constructor is used to initialize objects of its class type.
+[*Note 1*: Because constructors do not have names, they are never found
+during unqualified name lookup; however an explicit type conversion
+using the functional notation [[expr.type.conv]] will cause a
+constructor to be called to initialize an object. The syntax looks like
+an explicit call of the constructor. — *end note*]
 [*Example 2*:
 ``` cpp
 complex zz = complex(1,2.3);
 A constructor can be invoked for a `const`, `volatile` or `const`
 `volatile` object. `const` and `volatile` semantics [[dcl.type.cv]] are
 not applied on an object under construction. They come into effect when
 the constructor for the most derived object [[intro.object]] ends.
+The address of a constructor shall not be taken.
+[*Note 6*: A `return` statement in the body of a constructor cannot
+specify a return value [[stmt.return]]. — *end note*]
 A constructor shall not be a coroutine.
+A constructor shall not have an explicit object parameter [[dcl.fct]].
 #### Default constructors <a id="class.default.ctor">[[class.default.ctor]]</a>
 A *default constructor* for a class `X` is a constructor of class `X`
 for which each parameter that is not a function parameter pack has a
 default argument (including the case of a constructor with no
   type (or array thereof), each such class has a trivial default
   constructor.
 Otherwise, the default constructor is *non-trivial*.
+An implicitly-defined [[dcl.fct.def.default]] default constructor
 performs the set of initializations of the class that would be performed
 by a user-written default constructor for that class with no
 *ctor-initializer* [[class.base.init]] and an empty
 *compound-statement*. If that user-written default constructor would be
 ill-formed, the program is ill-formed. If that user-written default
+constructor would be constexpr-suitable [[dcl.constexpr]], the
+implicitly-defined default constructor is `constexpr`. Before the
+defaulted default constructor for a class is implicitly defined, all the
+non-user-provided default constructors for its base classes and its
+non-static data members are implicitly defined.
 [*Note 1*: An implicitly-declared default constructor has an exception
 specification [[except.spec]]. An explicitly-defaulted definition might
 have an implicit exception specification, see
 [[dcl.fct.def]]. — *end note*]
+[*Note 2*:  A default constructor is implicitly invoked to initialize a
+class object when no initializer is specified [[dcl.init.general]]. Such
+a default constructor is required to be accessible
+[[class.access]]. — *end note*]
+[*Note 3*:  [[class.base.init]] describes the order in which
 constructors for base classes and non-static data members are called and
 describes how arguments can be specified for the calls to these
 constructors. — *end note*]
 #### Copy/move constructors <a id="class.copy.ctor">[[class.copy.ctor]]</a>
 — *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