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

Files changed (1) hide show

tmp/tmpjvzc7h1k/{from.md → to.md} +18 -23

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

@@ -25,20 +25,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.
@@ -57,11 +55,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
@@ -145,14 +143,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*
@@ -167,11 +166,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.
@@ -193,14 +192,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*]
@@ -306,13 +305,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 {
@@ -331,15 +331,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
@@ -376,11 +371,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

 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

Diff to HTML by rtfpessoa