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

Files changed (1) hide show

tmp/tmp3vcc6u4h/{from.md → to.md} +289 -93

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

@@ -8,12 +8,14 @@ An object of class type (or array thereof) can be explicitly
 initialized; see  [[class.expl.init]] and  [[class.base.init]].
 When an array of class objects is initialized (either explicitly or
 implicitly) and the elements are initialized by constructor, the
 constructor shall be called for each element of the array, following the
-subscript order; see  [[dcl.array]]. Destructors for the array elements
-are called in reverse order of their construction.
 ### Explicit initialization <a id="class.expl.init">[[class.expl.init]]</a>
 An object of class type can be initialized with a parenthesized
 *expression-list*, where the *expression-list* is construed as an
@@ -21,43 +23,42 @@ argument list for a constructor that is called to initialize the object.
 Alternatively, a single *assignment-expression* can be specified as an
 *initializer* using the `=` form of initialization. Either
 direct-initialization semantics or copy-initialization semantics apply;
 see  [[dcl.init]].
 ``` cpp
 struct complex {
   complex();
   complex(double);
   complex(double,double);
 };
 complex sqrt(complex,complex);
-complex a(1);                   // initialize by a call of
-                                // complex(double)
 complex b = a;                  // initialize by a copy of a
-complex c = complex(1,2);       // construct complex(1,2)
-                                // using complex(double,double)
                                 // copy/move it into c
-complex d = sqrt(b,c);          // call sqrt(complex,complex)
- // and copy/move the result into d
-complex e; // initialize by a call of
- // complex()
-complex f = 3;                  // construct complex(3) using
-                                // complex(double)
-                                // copy/move it into f
-complex g = { 1, 2 };           // initialize by a call of
-                                // complex(double, double)
 ```
-overloading of the assignment operator ([[over.ass]]) has no effect on
-initialization.
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
 ``` cpp
 complex v[6] = { 1, complex(1,2), complex(), 2 };
 ```
 Here, `complex::complex(double)` is called for the initialization of
@@ -73,37 +74,41 @@ struct X {
 } x = { 99, 88.8, 77.7 };
 ```
 Here, `x.i` is initialized with 99, `x.f` is initialized with 88.8, and
 `complex::complex(double)` is called for the initialization of `x.c`.
-Braces can be elided in the *initializer-list* for any aggregate, even
-if the aggregate has members of a class type with user-defined type
-conversions; see  [[dcl.init.aggr]].
-If `T` is a class type with no default constructor, any declaration of
-an object of type `T` (or array thereof) is ill-formed if no
-*initializer* is explicitly specified (see  [[class.init]] and
-[[dcl.init]]).
-the order in which objects with static or thread storage duration are
-initialized is described in  [[basic.start.init]] and  [[stmt.dcl]].
 ### Initializing bases and members <a id="class.base.init">[[class.base.init]]</a>
 In the definition of a constructor for a class, initializers for direct
-and virtual base subobjects and non-static data members can be specified
-by a *ctor-initializer*, which has the form
 ``` bnf
 ctor-initializer:
     ':' mem-initializer-list
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
-    mem-initializer '...'ₒₚₜ ',' mem-initializer-list
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
@@ -117,123 +122,163 @@ mem-initializer-id:
 ```
 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. 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. 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.
 A *mem-initializer-list* can initialize a base class using any
 *class-or-decltype* that denotes that base class type.
 ``` cpp
 struct A { A(); };
 typedef A global_A;
 struct B { };
 struct C: public A, public B { C(); };
 C::C(): global_A() { }          // mem-initializer for base A
 ```
 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.
 ``` cpp
 struct A { A(); };
 struct B: public virtual A { };
 struct C: public A, public B { C(); };
 C::C(): A() { }                 // ill-formed: which A?
 ```
 A *ctor-initializer* may initialize a variant member of the
 constructor’s class. If a *ctor-initializer* specifies more than one
 *mem-initializer* for the same member or for the same base class, the
 *ctor-initializer* is ill-formed.
 A *mem-initializer-list* can delegate to another constructor of the
 constructor’s class using any *class-or-decltype* that denotes the
-constructor’s class itself. If a designates the constructor’s class, it
-shall be the only ; the constructor is a *delegating constructor*, and
-the constructor selected by the is the *target constructor*. The
-*principal constructor* is the first constructor invoked in the
-construction of an object (that is, not a target constructor for that
-object’s construction). The target constructor is selected by overload
-resolution. Once the target constructor returns, the body of the
-delegating constructor is executed. If a constructor delegates to itself
-directly or indirectly, the program is ill-formed; no diagnostic is
-required.
 ``` cpp
 struct C {
   C( int ) { }                  // #1: non-delegating constructor
   C(): C(42) { }                // #2: delegates to #1
   C( char c ) : C(42.0) { }     // #3: ill-formed due to recursion with #4
   C( double d ) : C('a') { }    // #4: ill-formed due to recursion with #3
 };
 ```
 The *expression-list* or *braced-init-list* in a *mem-initializer* is
 used to initialize the designated subobject (or, in the case of a
 delegating constructor, the complete class object) according to the
 initialization rules of  [[dcl.init]] for direct-initialization.
 ``` cpp
-struct B1 { B1(int); /* ... */ };
-struct B2 { B2(int); /* ... */ };
 struct D : B1, B2 {
   D(int);
   B1 b;
   const int c;
 };
-D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4)
-  { /* ... */ }
 D d(10);
 ```
-The initialization performed by each *mem-initializer* constitutes a
-full-expression. Any expression in a *mem-initializer* is evaluated as
-part of the full-expression that performs the initialization. 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.
 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
- *brace-or-equal-initializer* 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 as specified in  [[dcl.init]];
 - otherwise, if the entity is an anonymous union or a variant member (
-  [[class.union]]), no initialization is performed;
 - otherwise, the entity is default-initialized ([[dcl.init]]).
-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. An attempt to
-initialize more than one non-static data member of a union renders the
-program ill-formed. After the call to a constructor for class `X` for an
-object with automatic or dynamic storage duration has completed, if the
 constructor was not invoked as part of value-initialization and a member
 of `X` is neither initialized nor given a value during execution of the
 *compound-statement* of the body of the constructor, the member has an
-indeterminate value.
 ``` cpp
 struct A {
   A();
 };
@@ -249,32 +294,59 @@ struct C {
   int i;                // OK: i has indeterminate value
   int j = 5;            // OK: j has the value 5
 };
 ```
-If a given non-static data member has both a
-*brace-or-equal-initializer* and a *mem-initializer*, the initialization
-specified by the *mem-initializer* is performed, and the non-static data
-member’s *brace-or-equal-initializer* is ignored. Given
 ``` cpp
 struct A {
   int i = /* some integer expression with side effects */ ;
   A(int arg) : i(arg) { }
   // ...
 };
 ```
 the `A(int)` constructor will simply initialize `i` to the value of
-`arg`, and the side effects in `i`’s *brace-or-equal-initializer* will
-not take place.
 In a non-delegating constructor, the destructor for each potentially
 constructed subobject of class type is potentially invoked (
-[[class.dtor]]). This provision ensures that destructors can be called
-for fully-constructed sub-objects in case an exception is thrown (
-[[except.ctor]]).
 In a non-delegating constructor, initialization proceeds in the
 following order:
 - First, and only for the constructor of the most derived class (
@@ -283,18 +355,21 @@ following order:
   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
   appear in the *base-specifier-list* (regardless of the order of the
-  *mem-initializers*).
 - Then, non-static data members are initialized in the order they were
   declared in the class definition (again regardless of the order of the
-  *mem-initializers*).
 - Finally, the *compound-statement* of the constructor body is executed.
-The declaration order is mandated to ensure that base and member
-subobjects are destroyed in the reverse order of initialization.
 ``` cpp
 struct V {
   V();
   V(int);
@@ -313,24 +388,28 @@ struct B : virtual V {
 struct C : A, B, virtual V {
   C();
   C(int);
 };
-A::A(int i) : V(i) { /* ... */ }
-B::B(int i) { /* ... */ }
-C::C(int i) { /* ... */ }
 V v(1);             // use V(int)
 A a(2);             // use V(int)
 B b(3);             // use V()
 C c(4);             // use V()
 ```
 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.
 ``` cpp
 class X {
   int a;
   int b;
   int i;
@@ -343,22 +422,28 @@ public:
 initializes `X::r` to refer to `X::a`, initializes `X::b` with the value
 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.
-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.
 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
-result of the operation is undefined.
 ``` cpp
 class A {
 public:
   A(int);
@@ -366,12 +451,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:
@@ -379,28 +463,140 @@ 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
 };
 ```
-[[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.
 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.
 ``` cpp
 template<class... Mixins>
 class X : public Mixins... {
 public:
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 ```

 initialized; see  [[class.expl.init]] and  [[class.base.init]].
 When an array of class objects is initialized (either explicitly or
 implicitly) and the elements are initialized by constructor, the
 constructor shall be called for each element of the array, following the
+subscript order; see  [[dcl.array]].
+[*Note 1*: Destructors for the array elements are called in reverse
+order of their construction. — *end note*]
 ### Explicit initialization <a id="class.expl.init">[[class.expl.init]]</a>
 An object of class type can be initialized with a parenthesized
 *expression-list*, where the *expression-list* is construed as an
 Alternatively, a single *assignment-expression* can be specified as an
 *initializer* using the `=` form of initialization. Either
 direct-initialization semantics or copy-initialization semantics apply;
 see  [[dcl.init]].
+[*Example 1*:
 ``` cpp
 struct complex {
   complex();
   complex(double);
   complex(double,double);
 };
 complex sqrt(complex,complex);
+complex a(1);                   // initialize by a call of complex(double)
 complex b = a;                  // initialize by a copy of a
+complex c = complex(1,2);       // construct complex(1,2) using complex(double,double),
                                 // copy/move it into c
+complex d = sqrt(b,c);          // call sqrt(complex,complex) and copy/move the result into d
+complex e;                      // initialize by a call of complex()
+complex f = 3; // construct complex(3) using complex(double), copy/move it into f
+complex g = { 1, 2 };           // initialize by a call of complex(double, double)
 ```
+— *end example*]
+[*Note 1*:  Overloading of the assignment operator ([[over.ass]]) has
+no effect on initialization. — *end note*]
 An object of class type can also be initialized by a *braced-init-list*.
 List-initialization semantics apply; see  [[dcl.init]] and
 [[dcl.init.list]].
+[*Example 2*:
 ``` cpp
 complex v[6] = { 1, complex(1,2), complex(), 2 };
 ```
 Here, `complex::complex(double)` is called for the initialization of
 } x = { 99, 88.8, 77.7 };
 ```
 Here, `x.i` is initialized with 99, `x.f` is initialized with 88.8, and
 `complex::complex(double)` is called for the initialization of `x.c`.
+— *end example*]
+[*Note 2*: Braces can be elided in the *initializer-list* for any
+aggregate, even if the aggregate has members of a class type with
+user-defined type conversions; see  [[dcl.init.aggr]]. — *end note*]
+[*Note 3*: If `T` is a class type with no default constructor, any
+declaration of an object of type `T` (or array thereof) is ill-formed if
+no *initializer* is explicitly specified (see  [[class.init]] and
+[[dcl.init]]). — *end note*]
+[*Note 4*:  The order in which objects with static or thread storage
+duration are initialized is described in  [[basic.start.dynamic]] and
+[[stmt.dcl]]. — *end note*]
 ### Initializing bases and members <a id="class.base.init">[[class.base.init]]</a>
 In the definition of a constructor for a class, initializers for direct
+and virtual base class subobjects and non-static data members can be
+specified by a *ctor-initializer*, which has the form
 ``` bnf
 ctor-initializer:
     ':' mem-initializer-list
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
+    mem-initializer-list ',' mem-initializer '...'ₒₚₜ
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
 ```
 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.
 A *mem-initializer-list* can initialize a base class using any
 *class-or-decltype* that denotes that base class type.
+[*Example 1*:
 ``` cpp
 struct A { A(); };
 typedef A global_A;
 struct B { };
 struct C: public A, public B { C(); };
 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
 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
 constructor’s class. If a *ctor-initializer* specifies more than one
 *mem-initializer* for the same member or for the same base class, the
 *ctor-initializer* is ill-formed.
 A *mem-initializer-list* can delegate to another constructor of the
 constructor’s class using any *class-or-decltype* that denotes the
+constructor’s class itself. If a *mem-initializer-id* designates the
+constructor’s class, it shall be the only *mem-initializer*; the
+constructor is a *delegating constructor*, and the constructor selected
+by the *mem-initializer* is the *target constructor*. The target
+constructor is selected by overload resolution. Once the target
+constructor returns, the body of the delegating constructor is executed.
+If a constructor delegates to itself directly or indirectly, the program
+is ill-formed, no diagnostic required.
+[*Example 3*:
 ``` cpp
 struct C {
   C( int ) { }                  // #1: non-delegating constructor
   C(): C(42) { }                // #2: delegates to #1
   C( char c ) : C(42.0) { }     // #3: ill-formed due to recursion with #4
   C( double d ) : C('a') { }    // #4: ill-formed due to recursion with #3
 };
 ```
+— *end example*]
 The *expression-list* or *braced-init-list* in a *mem-initializer* is
 used to initialize the designated subobject (or, in the case of a
 delegating constructor, the complete class object) according to the
 initialization rules of  [[dcl.init]] for direct-initialization.
+[*Example 4*:
 ``` cpp
+struct B1 { B1(int); ... };
+struct B2 { B2(int); ... };
 struct D : B1, B2 {
   D(int);
   B1 b;
   const int c;
 };
+D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4) { ... }
 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.
+A temporary expression bound to a reference member in a
+*mem-initializer* is ill-formed.
+[*Example 5*:
+``` cpp
+struct A {
+  A() : v(42) { }   // error
+  const int& v;
+};
+```
+— *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*
     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.
+[*Note 4*: After the call to a constructor for class `X` for an object
+with automatic or dynamic storage duration has completed, if the
 constructor was not invoked as part of value-initialization and a member
 of `X` is neither initialized nor given a value during execution of the
 *compound-statement* of the body of the constructor, the member has an
+indeterminate value. — *end note*]
+[*Example 6*:
 ``` cpp
 struct A {
   A();
 };
   int i;                // OK: i has indeterminate value
   int j = 5;            // OK: j has the value 5
 };
 ```
+— *end example*]
+If a given non-static data member has both a default member initializer
+and a *mem-initializer*, the initialization specified by the
+*mem-initializer* is performed, and the non-static data member’s default
+member initializer is ignored.
+[*Example 7*:
+Given
 ``` cpp
 struct A {
   int i = /* some integer expression with side effects */ ;
   A(int arg) : i(arg) { }
   // ...
 };
 ```
 the `A(int)` constructor will simply initialize `i` to the value of
+`arg`, and the side effects in `i`’s default member initializer will not
+take place.
+— *end example*]
+A temporary expression bound to a reference member from a default member
+initializer is ill-formed.
+[*Example 8*:
+``` cpp
+struct A {
+  A() = default;        // OK
+  A(int v) : v(v) { }   // OK
+  const int& v = 42;    // OK
+};
+A a1;                   // error: ill-formed binding of temporary to reference
+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 (
   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
   appear in the *base-specifier-list* (regardless of the order of the
+  *mem-initializer*s).
 - Then, non-static data members are initialized in the order they were
   declared in the class definition (again regardless of the order of the
+  *mem-initializer*s).
 - Finally, the *compound-statement* of the constructor body is executed.
+[*Note 6*: The declaration order is mandated to ensure that base and
+member subobjects are destroyed in the reverse order of
+initialization. — *end note*]
+[*Example 9*:
 ``` cpp
 struct V {
   V();
   V(int);
 struct C : A, B, virtual V {
   C();
   C(int);
 };
+A::A(int i) : V(i) { ... }
+B::B(int i) { ... }
+C::C(int i) { ... }
 V v(1);             // use V(int)
 A a(2);             // use V(int)
 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 {
   int a;
   int b;
   int i;
 initializes `X::r` to refer to `X::a`, initializes `X::b` with the value
 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 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 {
 public:
   A(int);
 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:
 };
 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
 template<class... Mixins>
 class X : public Mixins... {
 public:
   X(const Mixins&... mixins) : Mixins(mixins)... { }
 };
 ```
+— *end example*]
+### Initialization by inherited constructor <a id="class.inhctor.init">[[class.inhctor.init]]</a>
+When a constructor for type `B` is invoked to initialize an object of a
+different type `D` (that is, when the constructor was inherited (
+[[namespace.udecl]])), initialization proceeds as if a defaulted default
+constructor were used to initialize the `D` object and each base class
+subobject from which the constructor was inherited, except that the `B`
+subobject is initialized by the invocation of the inherited constructor.
+The complete initialization is considered to be a single function call;
+in particular, the initialization of the inherited constructor’s
+parameters is sequenced before the initialization of any part of the `D`
+object.
+[*Example 1*:
+``` cpp
+struct B1 {
+  B1(int, ...) { }
+};
+struct B2 {
+  B2(double) { }
+};
+int get();
+struct D1 : B1 {
+  using B1::B1;     // inherits B1(int, ...)
+  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; }
+};
+```
+Class template `Log` wraps any class and forwards all of its
+constructors, while writing a message to the standard log whenever an
+object of class `Log` is destroyed.
+— *end example*]
+If the constructor was inherited from multiple base class subobjects of
+type `B`, the program is ill-formed.
+[*Example 2*:
+``` cpp
+struct A { A(int); };
+struct B : A { using A::A; };
+struct C1 : B { using B::B; };
+struct C2 : B { using B::B; };
+struct D1 : C1, C2 {
+  using C1::C1;
+  using C2::C2;
+};
+struct V1 : virtual B { using B::B; };
+struct V2 : virtual B { using B::B; };
+struct D2 : V1, V2 {
+  using V1::V1;
+  using V2::V2;
+};
+D1 d1(0);           // ill-formed: 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*]
+When an object is initialized by an inherited constructor,
+initialization of the object is complete when the initialization of all
+subobjects is complete.

Diff to HTML by rtfpessoa