[class.init] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpyz_mno9y/{from.md → to.md} +98 -64

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

@@ -47,12 +47,12 @@ complex f = 3;                  // initialized by calling complex(double) with a
 complex g = { 1, 2 };           // initialized by calling complex(double, double) with arguments 1 and 2
 ```
 — *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]].
@@ -83,13 +83,13 @@ Here, `x.i` is initialized with 99, `x.f` is initialized with 88.8, and
 [*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*]
@@ -130,11 +130,11 @@ 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 can 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.
@@ -272,11 +272,11 @@ 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 {
@@ -289,11 +289,11 @@ struct B {
 struct C {
   C() { }               // initializes members as follows:
   A a;                  // OK, calls A::A()
   const B b;            // error: B has no default constructor
-  int i;                // OK, i has indeterminate value
   int j = 5;            // OK, j has the value 5
 };
 ```
 — *end example*]
@@ -427,17 +427,23 @@ 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*]
 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 {
@@ -494,15 +500,19 @@ public:
 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 {
@@ -551,14 +561,33 @@ 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; };
@@ -620,11 +649,11 @@ int* p2 = &bobj.y.i;                    // undefined behavior: refers to member'
 A* pa = &bobj;                          // undefined behavior: upcast to a base class type
 B bobj;                                 // definition of bobj
 extern X xobj;
-int* p3 = &xobj.i;                      // OK, X is a trivial class
 X xobj;
 ```
 For another example,
@@ -639,14 +668,14 @@ struct Y {
 };
 ```
 — *end example*]
-During the construction of an object, if the value of the object or any
-of its subobjects is accessed through a glvalue that is not obtained,
-directly or indirectly, from the constructor’s `this` pointer, the value
-of the object or subobject thus obtained is unspecified.
 [*Example 2*:
 ``` cpp
 struct C;
@@ -712,11 +741,13 @@ struct E : C, D, X {
 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 which the call
 applies is the object (call it `x`) under construction or destruction,
 the function called is the final overrider in the 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
@@ -810,59 +841,62 @@ B::B(V* v, A* a) {
 — *end example*]
 ### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
 When certain criteria are met, an implementation is allowed to omit the
-copy/move construction of a class object, even if the constructor
-selected for the copy/move operation and/or the destructor for the
-object have side effects. In such cases, the implementation treats the
-source and target of the omitted copy/move operation as simply two
-different ways of referring to the same object. If the first parameter
-of the selected constructor is an rvalue reference to the object’s type,
-the destruction of that object occurs when the target would have been
-destroyed; otherwise, the destruction occurs at the later of the times
-when the two objects would have been destroyed without the
-optimization.[^14]
-This elision of copy/move operations, called *copy elision*, is
-permitted in the following circumstances (which may be combined to
-eliminate multiple copies):
-- in a `return` statement in a function with a class return type, when
- the *expression* is the name of a non-volatile object with automatic
-  storage duration (other than a function parameter or a variable
-  introduced by the *exception-declaration* of a *handler*
- [[except.handle]]) with the same type (ignoring cv-qualification) as
- the function return type, the copy/move operation can be omitted by
- constructing the object directly into the function call’s return
- object
 - in a *throw-expression* [[expr.throw]], when the operand is the name
-  of a non-volatile object with automatic storage duration (other than a
-  function or catch-clause parameter) that belongs to a scope that does
- not contain the innermost enclosing *compound-statement* associated
- with a *try-block* (if there is one), the copy/move operation can be
- omitted by constructing the object directly into the exception object
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
-  and destructor for the parameter copy object
-- when the *exception-declaration* of an exception handler
- [[except.pre]] declares an object of the same type (except for
- cv-qualification) as the exception object [[except.throw]], the copy
- operation can be omitted by treating the *exception-declaration* as an
- alias for the exception object if the meaning of the program will be
- unchanged except for the execution of constructors and destructors for
-  the object declared by the *exception-declaration*. \[*Note 1*: There
-  cannot be a move from the exception object because it is always an
-  lvalue. — *end note*]
 Copy elision is not permitted where an expression is evaluated in a
 context requiring a constant expression [[expr.const]] and in constant
 initialization [[basic.start.static]].
-[*Note 2*: It is possible that copy elision is performed if the same
 expression is evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp

 complex g = { 1, 2 };           // initialized by calling complex(double, double) with arguments 1 and 2
 ```
 — *end example*]
+[*Note 1*:  Overloading of the assignment operator [[over.assign]] 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]].
 [*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
+initializing 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*]
 *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 can be specified using a qualified
 name. — *end note*]
+Unless the *mem-initializer-id* names the constructor’s class, a direct
 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.
 [*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 or erroneous value [[basic.indet]]. — *end note*]
 [*Example 6*:
 ``` cpp
 struct A {
 struct C {
   C() { }               // initializes members as follows:
   A a;                  // OK, calls A::A()
   const B b;            // error: B has no default constructor
+  int i;                // OK, i has indeterminate or erroneous value
   int j = 5;            // OK, j has the value 5
 };
 ```
 — *end example*]
 `X::i`; this takes place each time an object of class `X` is created.
 — *end example*]
 Member functions (including virtual member functions, [[class.virtual]])
+can be called for an object under construction or destruction.
+Similarly, an object under construction or destruction can be the
+operand of the `typeid` operator [[expr.typeid]] or of a `dynamic_cast`
+[[expr.dynamic.cast]]. However, if these operations are performed during
+evaluation of
+- 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,
+- a precondition assertion of a constructor, or
+- a postcondition assertion of a destructor [[dcl.contract.func]],
+the program has undefined behavior.
 [*Example 11*:
 ``` cpp
 class 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 inherited constructor if the base class
+subobject were to be initialized as part of the `D` object
+[[class.base.init]]. The invocation of the inherited constructor,
+including the evaluation of any arguments, is omitted if the `B`
+subobject is not to be initialized as part of the `D` object. The
+complete initialization is considered to be a single function call; in
+particular, unless omitted, 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 {
 constructors, while writing a message to the standard log whenever an
 object of class `Log` is destroyed.
 — *end example*]
+[*Example 2*:
+``` cpp
+struct V { V() = default; V(int); };
+struct Q { Q(); };
+struct A : virtual V, Q {
+  using V::V;
+  A() = delete;
+};
+int bar() { return 42; }
+struct B : A {
+  B() : A(bar()) {} // OK
+};
+struct C : B {};
+void foo() { C c; } // bar is not invoked, because the V subobject is not initialized as part of B
+```
+— *end example*]
 If the constructor was inherited from multiple base class subobjects of
 type `B`, the program is ill-formed.
+[*Example 3*:
 ``` cpp
 struct A { A(int); };
 struct B : A { using A::A; };
 A* pa = &bobj;                          // undefined behavior: upcast to a base class type
 B bobj;                                 // definition of bobj
 extern X xobj;
+int* p3 = &xobj.i;                      // OK, all constructors of X are trivial
 X xobj;
 ```
 For another example,
 };
 ```
 — *end example*]
+During the construction of an object, if the value of any of its
+subobjects or any element of its object representation is accessed
+through a glvalue that is not obtained, directly or indirectly, from the
+constructor’s `this` pointer, the value thus obtained is unspecified.
 [*Example 2*:
 ``` cpp
 struct C;
 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, or during the evaluation of a
+postcondition assertion of a constructor or a precondition assertion of
+a destructor [[dcl.contract.func]], and the object to which the call
 applies is the object (call it `x`) under construction or destruction,
 the function called is the final overrider in the 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
 — *end example*]
 ### Copy/move elision <a id="class.copy.elision">[[class.copy.elision]]</a>
 When certain criteria are met, an implementation is allowed to omit the
+creation of a class object from a source object of the same type
+(ignoring cv-qualification), even if the selected constructor and/or the
+destructor for the object have side effects. In such cases, the
+implementation treats the source and target of the omitted
+initialization as simply two different ways of referring to the same
+object. If the first parameter of the selected constructor is an rvalue
+reference to the object’s type, the destruction of that object occurs
+when the target would have been destroyed; otherwise, the destruction
+occurs at the later of the times when the two objects would have been
+destroyed without the optimization.
+[*Note 1*: Because only one object is destroyed instead of two, and the
+creation of one object is omitted, there is still one object destroyed
+for each one constructed. — *end note*]
+This elision of object creation, called *copy elision*, is permitted in
+the following circumstances (which may be combined to eliminate multiple
+copies):
+- in a `return` statement [[stmt.return]] in a function with a class
+  return type, when the *expression* is the name of a non-volatile
+ object o with automatic storage duration (other than a function
+ parameter or a variable introduced by the *exception-declaration* of a
+  *handler* [[except.handle]]), the copy-initialization of the result
+  object can be omitted by constructing o directly into the function
+  call’s result object;
 - in a *throw-expression* [[expr.throw]], when the operand is the name
+  of a non-volatile object o with automatic storage duration (other than
+ a function parameter or a variable introduced by the
+ *exception-declaration* of a *handler*) that belongs to a scope that
+ does not contain the innermost enclosing *compound-statement*
+ associated with a *try-block* (if there is one), the
+  copy-initialization of the exception object can be omitted by
+  constructing o directly into the exception object;
 - in a coroutine [[dcl.fct.def.coroutine]], a copy of a coroutine
   parameter can be omitted and references to that copy replaced with
   references to the corresponding parameter if the meaning of the
   program will be unchanged except for the execution of a constructor
+  and destructor for the parameter copy object;
+- when the *exception-declaration* of a *handler* [[except.handle]]
+  declares an object o, the copy-initialization of o can be omitted by
+ treating the *exception-declaration* as an alias for the exception
+ object if the meaning of the program will be unchanged except for the
+ execution of constructors and destructors for the object declared by
+ the *exception-declaration*. \[*Note 2*: There cannot be a move from
+  the exception object because it is always an lvalue. — *end note*]
 Copy elision is not permitted where an expression is evaluated in a
 context requiring a constant expression [[expr.const]] and in constant
 initialization [[basic.start.static]].
+[*Note 3*: It is possible that copy elision is performed if the same
 expression is evaluated in another context. — *end note*]
 [*Example 1*:
 ``` cpp

Diff to HTML by rtfpessoa