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

Files changed (1) hide show

tmp/tmpwucwoqum/{from.md → to.md} +151 -67

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

@@ -1,20 +1,20 @@
 ### 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ₒₚₜ ')'
@@ -28,123 +28,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();
 };
@@ -160,32 +200,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 (
@@ -194,18 +261,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);
@@ -224,24 +294,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;
@@ -254,22 +328,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);
@@ -277,12 +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:
@@ -290,28 +369,33 @@ 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)... { }
 };
 ```

 ### 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*]

Diff to HTML by rtfpessoa