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

Files changed (1) hide show

tmp/tmpu4ddwukw/{from.md → to.md} +29 -16

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

@@ -43,13 +43,12 @@ complex d = sqrt(b,c);          // call sqrt(complex,complex)
 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 };           // construct complex(1, 2)
-                                // using complex(double, double)
-                                // and copy/move it into g
 ```
 overloading of the assignment operator ([[over.ass]]) has no effect on
 initialization.
@@ -100,11 +99,11 @@ ctor-initializer:
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
-    mem-initializer ',' mem-initializer-list '...'ₒₚₜ
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
@@ -202,31 +201,39 @@ 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 non-static data member or
-base class 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*) and the entity is not a virtual base class of
-an abstract class ([[class.abstract]]), then
 - if the entity is a non-static data member that has a
-  *brace-or-equal-initializer*, the entity is initialized as specified
- in  [[dcl.init]];
-- otherwise, if the entity is 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` has
-completed, if 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 indeterminate value.
 ``` cpp
 struct A {
   A();
 };
@@ -259,10 +266,16 @@ struct A {
 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, 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

 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.
 ```
 ``` bnf
 mem-initializer-list:
     mem-initializer '...'ₒₚₜ
+    mem-initializer '...'ₒₚₜ ',' mem-initializer-list
 ```
 ``` bnf
 mem-initializer:
     mem-initializer-id '(' expression-listₒₚₜ ')'
 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();
 };
 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 (
   [[intro.object]]), virtual base classes are initialized in the order

Diff to HTML by rtfpessoa