[class.cdtor] - C++14 → C++17

Files changed (1) hide show

tmp/tmp_kffhkrf/{from.md → to.md} +38 -29

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

@@ -5,10 +5,12 @@ non-static member or base class of the object before the constructor
 begins execution results in undefined behavior. For an object with a
 non-trivial destructor, referring to any non-static member or base class
 of the object after the destructor finishes execution results in
 undefined behavior.
 ``` cpp
 struct X { int i; };
 struct Y : X { Y(); };                  // non-trivial
 struct A { int a; };
 struct B : public A { int j; Y y; };    // non-trivial
@@ -37,10 +39,12 @@ struct Y {
   Y() : p(&x.j) {   // undefined, x is not yet constructed
     }
 };
 ```
 To explicitly or implicitly convert a pointer (a glvalue) referring to
 an object of class `X` to a pointer (reference) to a direct or indirect
 base class `B` of `X`, the construction of `X` and the construction of
 all of its direct or indirect bases that directly or indirectly derive
 from `B` shall have started and the destruction of these classes shall
@@ -49,31 +53,32 @@ behavior. To form a pointer to (or access the value of) a direct
 non-static member of an object `obj`, the construction of `obj` shall
 have started and its destruction shall not have completed, otherwise the
 computation of the pointer value (or accessing the member value) results
 in undefined behavior.
 ``` cpp
 struct A { };
 struct B : virtual A { };
 struct C : B { };
 struct D : virtual A { D(A*); };
 struct X { X(A*); };
 struct E : C, D, X {
-  E() : D(this),    // undefined: upcast from E* to A*
-                    // might use path E* → D* → A*
                     // but D is not constructed
-                    // D((C*)this), // defined:
-                    // E* → C* defined because E() has started
-                    // and C* → A* defined because
-                    // C fully constructed
-  X(this) { // defined: upon construction of X,
-                    // C/B/D/A sublattice is fully constructed
-  }
 };
 ```
 Member functions, including virtual functions ([[class.virtual]]), can
 be called during construction or destruction ([[class.base.init]]).
 When a virtual function is called directly or indirectly from a
 constructor or from a destructor, including during the construction or
 destruction of the class’s non-static data members, and the object to
@@ -83,10 +88,12 @@ constructor’s or destructor’s class and not one overriding it in a
 more-derived class. If the virtual function call uses an explicit class
 member access ([[expr.ref]]) and the object expression refers to the
 complete object of `x` or one of that object’s base class subobjects but
 not `x` or one of its base class subobjects, the behavior is undefined.
 ``` cpp
 struct V {
   virtual void f();
   virtual void g();
 };
@@ -112,36 +119,39 @@ B::B(V* v, A* a) {
   v->g();           // v is base of B, the call is well-defined, calls B::g
   a->f();           // undefined behavior, a's type not a base of B
 }
 ```
 The `typeid` operator ([[expr.typeid]]) can be used during construction
 or destruction ([[class.base.init]]). When `typeid` is used in a
-constructor (including the *mem-initializer* or
-*brace-or-equal-initializer* for a non-static data member) or in a
 destructor, or used in a function called (directly or indirectly) from a
 constructor or destructor, if the operand of `typeid` refers to the
 object under construction or destruction, `typeid` yields the
 `std::type_info` object representing the constructor or destructor’s
 class. If the operand of `typeid` refers to the object under
 construction or destruction and the static type of the operand is
 neither the constructor or destructor’s class nor one of its bases, the
-result of `typeid` is undefined.
 `dynamic_cast`s ([[expr.dynamic.cast]]) can be used during construction
 or destruction ([[class.base.init]]). When a `dynamic_cast` is used in
-a constructor (including the *mem-initializer* or
-*brace-or-equal-initializer* for a non-static data member) or in a
-destructor, or used in a function called (directly or indirectly) from a
-constructor or destructor, if the operand of the `dynamic_cast` refers
-to the object under construction or destruction, this object is
-considered to be a most derived object that has the type of the
-constructor or destructor’s class. If the operand of the `dynamic_cast`
-refers to the object under construction or destruction and the static
-type of the operand is not a pointer to or object of the constructor or
-destructor’s own class or one of its bases, the `dynamic_cast` results
-in undefined behavior.
 ``` cpp
 struct V {
   virtual void f();
 };
@@ -156,15 +166,14 @@ struct D : A, B {
   D() : B((A*)this, this) { }
 };
 B::B(V* v, A* a) {
   typeid(*this);                // type_info for B
-  typeid(*v);                   // well-defined: *v has type V, a base of B
-                                // yields type_info for B
   typeid(*a);                   // undefined behavior: type A not a base of B
-  dynamic_cast<B*>(v);          // well-defined: v of type V*, V base of B
- // results in B*
-  dynamic_cast<B*>(a);          // undefined behavior,
-                                // a has type A*, A not a base of B
 }
 ```

 begins execution results in undefined behavior. For an object with a
 non-trivial destructor, referring to any non-static member or base class
 of the object after the destructor finishes execution results in
 undefined behavior.
+[*Example 1*:
 ``` cpp
 struct X { int i; };
 struct Y : X { Y(); };                  // non-trivial
 struct A { int a; };
 struct B : public A { int j; Y y; };    // non-trivial
   Y() : p(&x.j) {   // undefined, x is not yet constructed
     }
 };
 ```
+— *end example*]
 To explicitly or implicitly convert a pointer (a glvalue) referring to
 an object of class `X` to a pointer (reference) to a direct or indirect
 base class `B` of `X`, the construction of `X` and the construction of
 all of its direct or indirect bases that directly or indirectly derive
 from `B` shall have started and the destruction of these classes shall
 non-static member of an object `obj`, the construction of `obj` shall
 have started and its destruction shall not have completed, otherwise the
 computation of the pointer value (or accessing the member value) results
 in undefined behavior.
+[*Example 2*:
 ``` cpp
 struct A { };
 struct B : virtual A { };
 struct C : B { };
 struct D : virtual A { D(A*); };
 struct X { X(A*); };
 struct E : C, D, X {
+  E() : D(this),    // undefined: upcast from E* to A* might use path E* → D* → A*
                     // but D is not constructed
+                    // ``D((C*)this)'' would be defined: E* → C* is defined because E() has started,
+                    // and C* → A* is defined because C is fully constructed
+  X(this) {}        // defined: upon construction of X, C/B/D/A sublattice is fully constructed
 };
 ```
+— *end example*]
 Member functions, including virtual functions ([[class.virtual]]), can
 be called during construction or destruction ([[class.base.init]]).
 When a virtual function is called directly or indirectly from a
 constructor or from a destructor, including during the construction or
 destruction of the class’s non-static data members, and the object to
 more-derived class. If the virtual function call uses an explicit class
 member access ([[expr.ref]]) and the object expression refers to the
 complete object of `x` or one of that object’s base class subobjects but
 not `x` or one of its base class subobjects, the behavior is undefined.
+[*Example 3*:
 ``` cpp
 struct V {
   virtual void f();
   virtual void g();
 };
   v->g();           // v is base of B, the call is well-defined, calls B::g
   a->f();           // undefined behavior, a's type not a base of B
 }
 ```
+— *end example*]
 The `typeid` operator ([[expr.typeid]]) can be used during construction
 or destruction ([[class.base.init]]). When `typeid` is used in a
+constructor (including the *mem-initializer* or default member
+initializer ([[class.mem]]) for a non-static data member) or in a
 destructor, or used in a function called (directly or indirectly) from a
 constructor or destructor, if the operand of `typeid` refers to the
 object under construction or destruction, `typeid` yields the
 `std::type_info` object representing the constructor or destructor’s
 class. If the operand of `typeid` refers to the object under
 construction or destruction and the static type of the operand is
 neither the constructor or destructor’s class nor one of its bases, the
+behavior is undefined.
 `dynamic_cast`s ([[expr.dynamic.cast]]) can be used during construction
 or destruction ([[class.base.init]]). When a `dynamic_cast` is used in
+a constructor (including the *mem-initializer* or default member
+initializer for a non-static data member) or in a destructor, or used in
+a function called (directly or indirectly) from a constructor or
+destructor, if the operand of the `dynamic_cast` refers to the object
+under construction or destruction, this object is considered to be a
+most derived object that has the type of the constructor or destructor’s
+class. If the operand of the `dynamic_cast` refers to the object under
+construction or destruction and the static type of the operand is not a
+pointer to or object of the constructor or destructor’s own class or one
+of its bases, the `dynamic_cast` results in undefined behavior.
+[*Example 4*:
 ``` cpp
 struct V {
   virtual void f();
 };
   D() : B((A*)this, this) { }
 };
 B::B(V* v, A* a) {
   typeid(*this);                // type_info for B
+  typeid(*v);                   // well-defined: *v has type V, a base of B yields type_info for B
   typeid(*a);                   // undefined behavior: type A not a base of B
+  dynamic_cast<B*>(v);          // well-defined: v of type V*, V base of B results in B*
+  dynamic_cast<B*>(a);          // undefined behavior, a has type A*, A not a base of B
 }
 ```
+— *end example*]

Diff to HTML by rtfpessoa