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

Files changed (1) hide show

tmp/tmp2atvq6yh/{from.md → to.md} +294 -97

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

@@ -1,34 +1,29 @@
-## Constructors <a id="class.ctor">[[class.ctor]]</a>
-Constructors do not have names. In a declaration of a constructor, the
-*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 but is not a friend declaration ([[class.friend]]), the
-  *id-expression* is the injected-class-name (Clause  [[class]]) of the
-  immediately-enclosing class;
-- in a *member-declaration* that belongs to the *member-specification*
-  of a class template but is not a friend declaration, the
-  *id-expression* is a *class-name* that names the current
-  instantiation ([[temp.dep.type]]) of the immediately-enclosing class
-  template; 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]]).
-The *class-name* shall not be a *typedef-name*. In a constructor
-declaration, each *decl-specifier* in the optional *decl-specifier-seq*
-shall be `friend`, `inline`, `explicit`, or `constexpr`.
 [*Example 1*:
 ``` cpp
 struct S {
@@ -40,169 +35,371 @@ 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*: For initialization of objects of class type see
 [[class.init]]. — *end note*]
 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 *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
 parameters). If there is no user-declared constructor for class `X`, a
 non-explicit constructor having no parameters is implicitly declared as
-defaulted ([[dcl.fct.def]]). An implicitly-declared default constructor
-is an `inline` `public` member of its class.
 A defaulted default constructor for class `X` is defined as deleted if:
 - `X` is a union that has a variant member with a non-trivial default
   constructor and no variant member of `X` has a default member
   initializer,
 - `X` is a non-union class that has a variant member `M` with a
   non-trivial default constructor and no variant member of the anonymous
   union containing `M` has a default member initializer,
-- any non-static data member with no default member initializer (
-  [[class.mem]]) is of reference type,
 - any non-variant non-static data member of const-qualified type (or
-  array thereof) with no *brace-or-equal-initializer* does not have a
- user-provided default constructor,
 - `X` is a union and all of its variant members are of const-qualified
   type (or array thereof),
 - `X` is a non-union class and all members of any anonymous union member
   are of const-qualified type (or array thereof),
 - any potentially constructed subobject, except for a non-static data
   member with a *brace-or-equal-initializer*, has class type `M` (or
   array thereof) and either `M` has no default constructor or overload
-  resolution ([[over.match]]) as applied to find `M`’s corresponding
   constructor results in an ambiguity or in a function that is deleted
   or inaccessible from the defaulted default constructor, or
 - any potentially constructed subobject has a type with a destructor
   that is deleted or inaccessible from the defaulted default
   constructor.
 A default constructor is *trivial* if it is not user-provided and if:
-- its class has no virtual functions ([[class.virtual]]) and no virtual
-  base classes ([[class.mi]]), and
 - no non-static data member of its class has a default member
-  initializer ([[class.mem]]), and
 - all the direct base classes of its class have trivial default
   constructors, and
 - for all the non-static data members of its class that are of class
   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]]) 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 shall have been
-implicitly defined.
-[*Note 2*: 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 (Clause  [[class.access]]).
-[*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*]
-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 functional notation type conversion ([[expr.type.conv]]) can be used
-to create new objects of its type.
-[*Note 4*: The syntax looks like an explicit call of the
-constructor. — *end note*]
 [*Example 2*:
 ``` cpp
-complex zz = complex(1,2.3);
-cprint( complex(7.8,1.2) );
 ```
 — *end example*]
-An object created in this way is unnamed.
-[*Note 5*:  [[class.temporary]] describes the lifetime of temporary
-objects. — *end note*]
-[*Note 6*: Explicit constructor calls do not yield lvalues, see
-[[basic.lval]]. — *end note*]
-[*Note 7*:  Some language constructs have special semantics when used
-during construction; see  [[class.base.init]] and
-[[class.cdtor]]. — *end note*]
-During the construction of an object, if the value of the object or any
-of its subobjects is accessed through a glvalue that is not obtained,
-directly or indirectly, from the constructor’s `this` pointer, the value
-of the object or subobject thus obtained is unspecified.
 [*Example 3*:
 ``` cpp
-struct C;
-void no_opt(C*);
-struct C {
-  int c;
- C() : c(0) { no_opt(this); }
 };
-const C cobj;
-void no_opt(C* cptr) {
- int i = cobj.c * 100;         // value of cobj.c is unspecified
-  cptr->c = 1;
-  cout << cobj.c * 100          // value of cobj.c is unspecified
-       << '\n';
 }
-extern struct D d;
-struct D {
-  D(int a) : a(a), b(d.a) {}
-  int a, b;
-};
-D d = D(1);                     // value of d.b is unspecified
 ```
 — *end example*]

+### 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 {
 — *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);
+cprint( complex(7.8,1.2) );
+```
+— *end example*]
+[*Note 2*: For initialization of objects of class type see
 [[class.init]]. — *end note*]
+An object created in this way is unnamed.
+[*Note 3*:  [[class.temporary]] describes the lifetime of temporary
+objects. — *end note*]
+[*Note 4*: Explicit constructor calls do not yield lvalues, see
+[[basic.lval]]. — *end note*]
+[*Note 5*:  Some language constructs have special semantics when used
+during construction; see  [[class.base.init]] and
+[[class.cdtor]]. — *end note*]
 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
 parameters). If there is no user-declared constructor for class `X`, a
 non-explicit constructor having no parameters is implicitly declared as
+defaulted [[dcl.fct.def]]. An implicitly-declared default constructor is
+an inline public member of its class.
 A defaulted default constructor for class `X` is defined as deleted if:
 - `X` is a union that has a variant member with a non-trivial default
   constructor and no variant member of `X` has a default member
   initializer,
 - `X` is a non-union class that has a variant member `M` with a
   non-trivial default constructor and no variant member of the anonymous
   union containing `M` has a default member initializer,
+- any non-static data member with no default member initializer
+  [[class.mem]] is of reference type,
 - any non-variant non-static data member of const-qualified type (or
+  array thereof) with no *brace-or-equal-initializer* is not
+ const-default-constructible [[dcl.init]],
 - `X` is a union and all of its variant members are of const-qualified
   type (or array thereof),
 - `X` is a non-union class and all members of any anonymous union member
   are of const-qualified type (or array thereof),
 - any potentially constructed subobject, except for a non-static data
   member with a *brace-or-equal-initializer*, has class type `M` (or
   array thereof) and either `M` has no default constructor or overload
+  resolution [[over.match]] as applied to find `M`’s corresponding
   constructor results in an ambiguity or in a function that is deleted
   or inaccessible from the defaulted default constructor, or
 - any potentially constructed subobject has a type with a destructor
   that is deleted or inaccessible from the defaulted default
   constructor.
 A default constructor is *trivial* if it is not user-provided and if:
+- its class has no virtual functions [[class.virtual]] and no virtual
+  base classes [[class.mi]], and
 - no non-static data member of its class has a default member
+  initializer [[class.mem]], and
 - all the direct base classes of its class have trivial default
   constructors, and
 - for all the non-static data members of its class that are of class
   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>
+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&);
+  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 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 cv `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 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 {
+ template<typename T> S(T);
+  S();
 };
+S g;
+void h() {
+ 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 [[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&)
+```
+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
+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
+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)`;
+- 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 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