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

Files changed (1) hide show

tmp/tmpiwc2m_1s/{from.md → to.md} +71 -81

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

@@ -1,7 +1,9 @@
 ## Initialization <a id="class.init">[[class.init]]</a>
 When no initializer is specified for an object of (possibly
 cv-qualified) class type (or array thereof), or the initializer has the
 form `()`, the object is initialized as specified in  [[dcl.init]].
 An object of class type (or array thereof) can be explicitly
@@ -61,11 +63,11 @@ complex v[6] = { 1, complex(1,2), complex(), 2 };
 ```
 Here, `complex::complex(double)` is called for the initialization of
 `v[0]` and `v[3]`, `complex::complex({}double, double)` is called for
 the initialization of `v[1]`, `complex::complex()` is called for the
-initialization `v[2]`, `v[4]`, and `v[5]`. For another example,
 ``` cpp
 struct X {
   int i;
   float f;
@@ -118,20 +120,18 @@ mem-initializer:
 mem-initializer-id:
     class-or-decltype
     identifier
 ```
-In a *mem-initializer-id* an initial unqualified *identifier* is looked
-up in the scope of the constructor’s class and, if not found in that
-scope, it is looked up in the scope containing the constructor’s
-definition.
 [*Note 1*: If the constructor’s class contains a member with the same
 name as a direct or virtual base class of the class, a
 *mem-initializer-id* naming the member or base class and composed of a
 single identifier refers to the class member. A *mem-initializer-id* for
-the hidden base class may be specified using a qualified
 name. — *end note*]
 Unless the *mem-initializer-id* names the constructor’s class, a
 non-static data member of the constructor’s class, or a direct or
 virtual base of that class, the *mem-initializer* is ill-formed.
@@ -150,11 +150,11 @@ C::C(): global_A() { }          // mem-initializer for base A
 ```
 — *end example*]
 If a *mem-initializer-id* is ambiguous because it designates both a
-direct non-virtual base class and an inherited virtual base class, the
 *mem-initializer* is ill-formed.
 [*Example 2*:
 ``` cpp
@@ -238,14 +238,15 @@ struct A {
 };
 ```
 — *end example*]
-In a non-delegating constructor, if a given potentially constructed
-subobject is not designated by a *mem-initializer-id* (including the
-case where there is no *mem-initializer-list* because the constructor
-has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
   initializer [[class.mem]] and either
   - the constructor’s class is a union [[class.union]], and no other
     variant member of that union is designated by a *mem-initializer-id*
@@ -260,11 +261,11 @@ has no *ctor-initializer*), then
   [[class.union.anon]], no initialization is performed;
 - otherwise, the entity is default-initialized [[dcl.init]].
 [*Note 3*: An abstract class [[class.abstract]] is never a most derived
 class, thus its constructors never initialize virtual base classes,
-therefore the corresponding *mem-initializer*s may be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
@@ -286,14 +287,14 @@ struct B {
   B(int);
 };
 struct C {
   C() { }               // initializes members as follows:
-  A a;                  // OK: calls A::A()
   const B b;            // error: B has no default constructor
-  int i;                // OK: i has indeterminate value
-  int j = 5;            // OK: j has the value 5
 };
 ```
 — *end example*]
@@ -399,13 +400,14 @@ B b(3);             // use V()
 C c(4);             // use V()
 ```
 — *end example*]
-Names in the *expression-list* or *braced-init-list* of a
-*mem-initializer* are evaluated in the scope of the constructor for
-which the *mem-initializer* is specified.
 [*Example 10*:
 ``` cpp
 class X {
@@ -424,15 +426,10 @@ of the constructor parameter `i`, initializes `X::i` with the value of
 the constructor parameter `i`, and initializes `X::j` with the value of
 `X::i`; this takes place each time an object of class `X` is created.
 — *end example*]
-[*Note 7*: Because the *mem-initializer* are evaluated in the scope of
-the constructor, the `this` pointer can be used in the *expression-list*
-of a *mem-initializer* to refer to the object being
-initialized. — *end note*]
 Member functions (including virtual member functions, [[class.virtual]])
 can be called for an object under construction. Similarly, an object
 under construction can be the operand of the `typeid` operator
 [[expr.typeid]] or of a `dynamic_cast` [[expr.dynamic.cast]]. However,
 if these operations are performed in a *ctor-initializer* (or in a
@@ -469,11 +466,11 @@ public:
 };
 ```
 — *end example*]
-[*Note 8*:  [[class.cdtor]] describes the result of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
 well-defined cases; that is, describes the polymorphic behavior of an
 object under construction. — *end note*]
 A *mem-initializer* followed by an ellipsis is a pack expansion
@@ -523,28 +520,28 @@ struct D1 : B1 {
   int x;
   int y = get();
 };
 void test() {
-  D1 d(2, 3, 4);    // OK: B1 is initialized by calling B1(2, 3, 4),
                     // then d.x is default-initialized (no initialization is performed),
                     // then d.y is initialized by calling get()
-  D1 e;             // error: D1 has a deleted default constructor
 }
 struct D2 : B2 {
   using B2::B2;
   B1 b;
 };
-D2 f(1.0);          // error: B1 has a deleted default constructor
 struct W { W(int); };
 struct X : virtual W { using W::W; X() = delete; };
 struct Y : X { using X::X; };
 struct Z : Y, virtual W { using Y::Y; };
-Z z(0);             // OK: initialization of Y does not invoke default constructor of X
 template<class T> struct Log : T {
   using T::T;       // inherits all constructors from class T
   ~Log() { std::clog << "Destroying wrapper" << std::endl; }
 };
@@ -580,18 +577,18 @@ struct D2 : V1, V2 {
   using V1::V1;
   using V2::V2;
 };
 D1 d1(0);           // error: ambiguous
-D2 d2(0);           // OK: initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
 struct O : M {};
 struct P : N, O { using N::N; using O::O; };
-P p(0);             // OK: use M(0) to initialize N's base class,
                     // use M() to initialize O's base class
 ```
 — *end example*]
@@ -822,13 +819,15 @@ 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.[^14] 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 object with automatic
   storage duration (other than a function parameter or a variable
   introduced by the *exception-declaration* of a *handler*
@@ -836,14 +835,14 @@ combined to eliminate multiple copies):
   the function return type, the copy/move operation can be omitted by
   constructing the 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 object with automatic storage duration (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 can be omitted by constructing the object directly
-  into the exception object
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
   and destructor for the parameter copy object
@@ -859,12 +858,12 @@ combined to eliminate multiple copies):
 Copy elision is not permitted 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 be performed if the same expression is
-evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
 class Thing {
@@ -893,54 +892,25 @@ constexpr A g() {
 constexpr A a;          // well-formed, a.p points to a
 constexpr A b = g();    // error: b.p would be dangling[expr.const]
 void h() {
-  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 object
 `t` with automatic storage duration 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 object with automatic
-storage duration to `t2` that is elided.
 — *end example*]
-An *implicitly movable entity* is a variable of automatic storage
-duration that is either a non-volatile object or an rvalue reference to
-a non-volatile object type. In the following copy-initialization
-contexts, a move operation might be used instead of a copy operation:
-- If the *expression* in a `return` [[stmt.return]] or `co_return`
-  [[stmt.return.coroutine]] statement is a (possibly parenthesized)
-  *id-expression* that names an implicitly movable entity 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 a (possibly
-  parenthesized) *id-expression* that names an implicitly movable entity
-  whose scope does not extend beyond the *compound-statement* of the
-  innermost *try-block* or *function-try-block* (if any) whose
-  *compound-statement* or *ctor-initializer* encloses the
-  *throw-expression*,
-overload resolution to select the constructor for the copy or the
-`return_value` overload to call is first performed as if the expression
-or operand were an rvalue. If the first overload resolution fails or was
-not performed, overload resolution is performed again, considering the
-expression or operand as an lvalue.
-[*Note 3*: This two-stage overload resolution must be performed
-regardless of whether copy elision will occur. It determines the
-constructor or the `return_value` overload to be called if elision is
-not performed, and the selected constructor or `return_value` overload
-must be accessible even if the call is elided. — *end note*]
 [*Example 2*:
 ``` cpp
 class Thing {
 public:
@@ -952,24 +922,44 @@ private:
 };
 Thing f(bool b) {
   Thing t;
   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*]

 ## Initialization <a id="class.init">[[class.init]]</a>
+### General <a id="class.init.general">[[class.init.general]]</a>
 When no initializer is specified for an object of (possibly
 cv-qualified) class type (or array thereof), or the initializer has the
 form `()`, the object is initialized as specified in  [[dcl.init]].
 An object of class type (or array thereof) can be explicitly
 ```
 Here, `complex::complex(double)` is called for the initialization of
 `v[0]` and `v[3]`, `complex::complex({}double, double)` is called for
 the initialization of `v[1]`, `complex::complex()` is called for the
+initialization of `v[2]`, `v[4]`, and `v[5]`. For another example,
 ``` cpp
 struct X {
   int i;
   float f;
 mem-initializer-id:
     class-or-decltype
     identifier
 ```
+Lookup for an unqualified name in a *mem-initializer-id* ignores the
+constructor’s function parameter scope.
 [*Note 1*: If the constructor’s class contains a member with the same
 name as a direct or virtual base class of the class, a
 *mem-initializer-id* naming the member or base class and composed of a
 single identifier refers to the class member. A *mem-initializer-id* for
+the hidden base class can be specified using a qualified
 name. — *end note*]
 Unless the *mem-initializer-id* names the constructor’s class, a
 non-static data member of the constructor’s class, or a direct or
 virtual base of that class, the *mem-initializer* is ill-formed.
 ```
 — *end example*]
 If a *mem-initializer-id* is ambiguous because it designates both a
+direct non-virtual base class and an indirect virtual base class, the
 *mem-initializer* is ill-formed.
 [*Example 2*:
 ``` cpp
 };
 ```
 — *end example*]
+In a non-delegating constructor other than an implicitly-defined
+copy/move constructor [[class.copy.ctor]], if a given potentially
+constructed subobject is not designated by a *mem-initializer-id*
+(including the case where there is no *mem-initializer-list* because the
+constructor has no *ctor-initializer*), then
 - if the entity is a non-static data member that has a default member
   initializer [[class.mem]] and either
   - the constructor’s class is a union [[class.union]], and no other
     variant member of that union is designated by a *mem-initializer-id*
   [[class.union.anon]], no initialization is performed;
 - otherwise, the entity is default-initialized [[dcl.init]].
 [*Note 3*: An abstract class [[class.abstract]] is never a most derived
 class, thus its constructors never initialize virtual base classes,
+therefore the corresponding *mem-initializer*s can be
 omitted. — *end note*]
 An attempt to initialize more than one non-static data member of a union
 renders the program ill-formed.
   B(int);
 };
 struct C {
   C() { }               // initializes members as follows:
+  A a;                  // OK, calls A::A()
   const B b;            // error: B has no default constructor
+  int i;                // OK, i has indeterminate value
+  int j = 5;            // OK, j has the value 5
 };
 ```
 — *end example*]
 C c(4);             // use V()
 ```
 — *end example*]
+[*Note 7*: The *expression-list* or *braced-init-list* of a
+*mem-initializer* is in the function parameter scope of the constructor
+and can use `this` to refer to the object being
+initialized. — *end note*]
 [*Example 10*:
 ``` cpp
 class X {
 the constructor parameter `i`, and initializes `X::j` with the value of
 `X::i`; this takes place each time an object of class `X` is created.
 — *end example*]
 Member functions (including virtual member functions, [[class.virtual]])
 can be called for an object under construction. Similarly, an object
 under construction can be the operand of the `typeid` operator
 [[expr.typeid]] or of a `dynamic_cast` [[expr.dynamic.cast]]. However,
 if these operations are performed in a *ctor-initializer* (or in a
 };
 ```
 — *end example*]
+[*Note 8*:  [[class.cdtor]] describes the results of virtual function
 calls, `typeid` and `dynamic_cast`s during construction for the
 well-defined cases; that is, describes the polymorphic behavior of an
 object under construction. — *end note*]
 A *mem-initializer* followed by an ellipsis is a pack expansion
   int x;
   int y = get();
 };
 void test() {
+  D1 d(2, 3, 4);    // OK, B1 is initialized by calling B1(2, 3, 4),
                     // then d.x is default-initialized (no initialization is performed),
                     // then d.y is initialized by calling get()
+  D1 e;             // error: D1 has no default constructor
 }
 struct D2 : B2 {
   using B2::B2;
   B1 b;
 };
+D2 f(1.0);          // error: B1 has no default constructor
 struct W { W(int); };
 struct X : virtual W { using W::W; X() = delete; };
 struct Y : X { using X::X; };
 struct Z : Y, virtual W { using Y::Y; };
+Z z(0);             // OK, initialization of Y does not invoke default constructor of X
 template<class T> struct Log : T {
   using T::T;       // inherits all constructors from class T
   ~Log() { std::clog << "Destroying wrapper" << std::endl; }
 };
   using V1::V1;
   using V2::V2;
 };
 D1 d1(0);           // error: ambiguous
+D2 d2(0);           // OK, initializes virtual B base class, which initializes the A base class
                     // then initializes the V1 and V2 base classes as if by a defaulted default constructor
 struct M { M(); M(int); };
 struct N : M { using M::M; };
 struct O : M {};
 struct P : N, O { using N::N; using O::O; };
+P p(0);             // OK, use M(0) to initialize N's base class,
                     // use M() to initialize O's base class
 ```
 — *end example*]
 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.[^14]
+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 object with automatic
   storage duration (other than a function parameter or a variable
   introduced by the *exception-declaration* of a *handler*
   the function return type, the copy/move operation can be omitted by
   constructing the 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 object with automatic storage duration (other than a
+  function or catch-clause parameter) that belongs to a scope that does
+ not contain the innermost enclosing *compound-statement* associated
+ with a *try-block* (if there is one), the copy/move operation can be
+ omitted by constructing the object directly into the exception object
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
   and destructor for the parameter copy object
 Copy elision is not permitted where an expression is evaluated in a
 context requiring a constant expression [[expr.const]] and in constant
 initialization [[basic.start.static]].
+[*Note 2*: It is possible that copy elision is performed if the same
+expression is evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp
 class Thing {
 constexpr A a;          // well-formed, a.p points to a
 constexpr A b = g();    // error: b.p would be dangling[expr.const]
 void h() {
+  A c = g();            // well-formed, c.p can point to c or be dangling
 }
 ```
 Here the criteria for elision can eliminate the copying of the object
 `t` with automatic storage duration into the result object for the
+function call `f()`, which is the non-local object `t2`. Effectively,
+the construction of `t` can be viewed as directly initializing `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 object with automatic storage duration to `t2`
+that is elided.
 — *end example*]
 [*Example 2*:
 ``` cpp
 class Thing {
 public:
 };
 Thing f(bool b) {
   Thing t;
   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(bool b) {
+ static Weird w1;
+ Weird w2;
+  if (b)
+    return w1;  // OK, uses Weird(Weird&)
+  else
+    return w2;  // error: w2 in this context is an xvalue
+}
+int& h(bool b, int i) {
+  static int s;
+  if (b)
+    return s;   // OK
+  else
+    return i;   // error: i is an xvalue
+}
+decltype(auto) h2(Thing t) {
+  return t;     // OK, t is an xvalue and h2's return type is Thing
+}
+decltype(auto) h3(Thing t) {
+  return (t);   // OK, (t) is an xvalue and h3's return type is Thing&&
 }
 ```
 — *end example*]

Diff to HTML by rtfpessoa