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

Files changed (1) hide show

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

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

@@ -66,11 +66,11 @@ direct non-virtual base class and an inherited virtual base class, the
 ``` cpp
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
-C::C(): A() { }                 // ill-formed: which A?
 ```
 — *end example*]
 A *ctor-initializer* may initialize a variant member of the
@@ -123,12 +123,12 @@ D d(10);
 ```
 — *end example*]
 [*Note 2*: The initialization performed by each *mem-initializer*
-constitutes a full-expression ([[intro.execution]]). Any expression in
-a *mem-initializer* is evaluated as part of the full-expression that
 performs the initialization. — *end note*]
 A *mem-initializer* where the *mem-initializer-id* denotes a virtual
 base class is ignored during execution of a constructor of any class
 that is not the most derived class.
@@ -151,27 +151,27 @@ 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*
     or
   - the constructor’s class is not a union, and, if the entity is a
     member of an anonymous union, no other member of that union is
     designated by a *mem-initializer-id*,
   the entity is initialized from its default member initializer as
   specified in  [[dcl.init]];
-- otherwise, if the entity is an anonymous union or a variant member (
-  [[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.
@@ -243,22 +243,22 @@ A a2(1);                // OK, unfortunately
 ```
 — *end example*]
 In a non-delegating constructor, the destructor for each potentially
-constructed subobject of class type is potentially invoked (
-[[class.dtor]]).
 [*Note 5*: This provision ensures that destructors can be called for
-fully-constructed subobjects in case an exception is thrown (
-[[except.ctor]]). — *end note*]
 In a non-delegating constructor, initialization proceeds in the
 following order:
-- First, and only for the constructor of the most derived class (
-  [[intro.object]]), virtual base classes are initialized in the order
   they appear on a depth-first left-to-right traversal of the directed
   acyclic graph of base classes, where “left-to-right” is the order of
   appearance of the base classes in the derived class
   *base-specifier-list*.
 - Then, direct base classes are initialized in declaration order as they
@@ -338,16 +338,16 @@ 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 function called directly or indirectly from a *ctor-initializer*)
-before all the *mem-initializer*s for base classes have completed, the
-program has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
@@ -357,11 +357,11 @@ public:
 class B : public A {
   int j;
 public:
   int f();
-  B() : A(f()),     // undefined: calls member function but base A not yet initialized
   j(f()) { }        // well-defined: bases are all initialized
 };
 class C {
 public:
@@ -369,24 +369,24 @@ public:
 };
 class D : public B, C {
   int i;
 public:
-  D() : C(f()),     // undefined: calls member function but base C not yet initialized
   i(f()) { }        // well-defined: bases are all initialized
 };
 ```
 — *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 (
-[[temp.variadic]]) that initializes the base classes specified by a pack
 expansion in the *base-specifier-list* for the class.
 [*Example 12*:
 ``` cpp

 ``` cpp
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
+C::C(): A() { }                 // error: which A?
 ```
 — *end example*]
 A *ctor-initializer* may initialize a variant member of the
 ```
 — *end example*]
 [*Note 2*: The initialization performed by each *mem-initializer*
+constitutes a full-expression [[intro.execution]]. Any expression in a
+*mem-initializer* is evaluated as part of the full-expression that
 performs the initialization. — *end note*]
 A *mem-initializer* where the *mem-initializer-id* denotes a virtual
 base class is ignored during execution of a constructor of any class
 that is not the most derived class.
 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*
     or
   - the constructor’s class is not a union, and, if the entity is a
     member of an anonymous union, no other member of that union is
     designated by a *mem-initializer-id*,
   the entity is initialized from its default member initializer as
   specified in  [[dcl.init]];
+- otherwise, if the entity is an anonymous union or a variant member
+  [[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.
 ```
 — *end example*]
 In a non-delegating constructor, the destructor for each potentially
+constructed subobject of class type is potentially invoked
+[[class.dtor]].
 [*Note 5*: This provision ensures that destructors can be called for
+fully-constructed subobjects in case an exception is thrown
+[[except.ctor]]. — *end note*]
 In a non-delegating constructor, initialization proceeds in the
 following order:
+- First, and only for the constructor of the most derived class
+  [[intro.object]], virtual base classes are initialized in the order
   they appear on a depth-first left-to-right traversal of the directed
   acyclic graph of base classes, where “left-to-right” is the order of
   appearance of the base classes in the derived class
   *base-specifier-list*.
 - Then, direct base classes are initialized in declaration order as they
 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
+function called directly or indirectly from a *ctor-initializer*) before
+all the *mem-initializer*s for base classes have completed, the program
+has undefined behavior.
 [*Example 11*:
 ``` cpp
 class A {
 class B : public A {
   int j;
 public:
   int f();
+  B() : A(f()),     // undefined behavior: calls member function but base A not yet initialized
   j(f()) { }        // well-defined: bases are all initialized
 };
 class C {
 public:
 };
 class D : public B, C {
   int i;
 public:
+  D() : C(f()),     // undefined behavior: calls member function but base C not yet initialized
   i(f()) { }        // well-defined: bases are all initialized
 };
 ```
 — *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
+[[temp.variadic]] that initializes the base classes specified by a pack
 expansion in the *base-specifier-list* for the class.
 [*Example 12*:
 ``` cpp

Diff to HTML by rtfpessoa