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

Files changed (1) hide show

tmp/tmprecvsoyc/{from.md → to.md} +77 -61

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

@@ -1,36 +1,36 @@
 ### Temporary objects <a id="class.temporary">[[class.temporary]]</a>
-Temporary objects are created
-- when a prvalue is converted to an xvalue [[conv.rval]],
 - when needed by the implementation to pass or return an object of
- trivially copyable type (see below), and
-- when throwing an exception [[except.throw]]. \[*Note 1*: The lifetime
-  of exception objects is described in  [[except.throw]]. — *end note*]
 Even when the creation of the temporary object is unevaluated
 [[expr.context]], all the semantic restrictions shall be respected as if
 the temporary object had been created and later destroyed.
-[*Note 2*: This includes accessibility [[class.access]] and whether it
 is deleted, for the constructor selected and for the destructor.
 However, in the special case of the operand of a *decltype-specifier*
 [[dcl.type.decltype]], no temporary is introduced, so the foregoing does
 not apply to such a prvalue. — *end note*]
 The materialization of a temporary object is generally delayed as long
 as possible in order to avoid creating unnecessary temporary objects.
-[*Note 3*:
 Temporary objects are materialized:
 - when binding a reference to a prvalue
   [[dcl.init.ref]], [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]],
-- when performing member access on a class prvalue
   [[expr.ref]], [[expr.mptr.oper]],
 - when performing an array-to-pointer conversion or subscripting on an
   array prvalue [[conv.array]], [[expr.sub]],
 - when initializing an object of type `std::initializer_list<T>` from a
   *braced-init-list* [[dcl.init.list]],
 - for certain unevaluated operands [[expr.typeid]], [[expr.sizeof]], and
@@ -78,49 +78,56 @@ result is constructed directly in `c`. On the other hand, the expression
 materialized so that the reference parameter of `X::operator=(const X&)`
 can bind to it.
 — *end example*]
-When an object of class type `X` is passed to or returned from a
-function, if `X` has at least one eligible copy or move constructor
-[[special]], each such constructor is trivial, and the destructor of `X`
-is either trivial or deleted, implementations are permitted to create a
-temporary object to hold the function parameter or result object. The
-temporary object is constructed from the function argument or return
-value, respectively, and the function’s parameter or return object is
-initialized as if by using the eligible trivial constructor to copy the
-temporary (even if that constructor is inaccessible or would not be
-selected by overload resolution to perform a copy or move of the
-object).
-[*Note 4*: This latitude is granted to allow objects of class type to
-be passed to or returned from functions in registers. — *end note*]
-When an implementation introduces a temporary object of a class that has
-a non-trivial constructor [[class.default.ctor]], [[class.copy.ctor]],
-it shall ensure that a constructor is called for the temporary object.
-Similarly, the destructor shall be called for a temporary with a
-non-trivial destructor [[class.dtor]]. Temporary objects are destroyed
-as the last step in evaluating the full-expression [[intro.execution]]
-that (lexically) contains the point where they were created. This is
-true even if that evaluation ends in throwing an exception. The value
-computations and side effects of destroying a temporary object are
-associated only with the full-expression, not with any specific
-subexpression.
-There are four contexts in which temporaries are destroyed at a
-different point than the end of the full-expression. The first context
-is when a default constructor is called to initialize an element of an
-array with no corresponding initializer [[dcl.init]]. The second context
-is when a copy constructor is called to copy an element of an array
-while the entire array is copied
 [[expr.prim.lambda.capture]], [[class.copy.ctor]]. In either case, if
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
-The third context is when a reference binds to a temporary object.[^13]
 The temporary object to which the reference is bound or the temporary
 object that is the complete object of a subobject to which the reference
 is bound persists for the lifetime of the reference if the glvalue to
 which the reference is bound was obtained through one of the following:
@@ -162,11 +169,11 @@ int&& c = cond ? id<int[3]>{1, 2, 3}[i] : static_cast<int&&>(0);
                                             // exactly one of the two temporaries is lifetime-extended
 ```
 — *end example*]
-[*Note 5*:
 An explicit type conversion [[expr.type.conv]], [[expr.cast]] is
 interpreted as a sequence of elementary casts, covered above.
 [*Example 3*:
@@ -177,11 +184,11 @@ const int& x = (const int&)1;   // temporary for value 1 has same lifetime as x
 — *end example*]
 — *end note*]
-[*Note 6*:
 If a temporary object has a reference member initialized by another
 temporary object, lifetime extension applies recursively to such a
 member’s initializer.
@@ -205,43 +212,52 @@ The exceptions to this lifetime rule are:
   containing the call.
 - A temporary object bound to a reference element of an aggregate of
   class type initialized from a parenthesized *expression-list*
   [[dcl.init]] persists until the completion of the full-expression
   containing the *expression-list*.
-- The lifetime of a temporary bound to the returned value in a function
-  `return` statement [[stmt.return]] is not extended; the temporary is
-  destroyed at the end of the full-expression in the `return` statement.
 - A temporary bound to a reference in a *new-initializer* [[expr.new]]
   persists until the completion of the full-expression containing the
   *new-initializer*.
-  \[*Note 7*: This might introduce a dangling reference. — *end note*]
   \[*Example 5*:
   ``` cpp
   struct S { int mi; const std::pair<int,int>& mp; };
   S a { 1, {2,3} };
   S* p = new S{ 1, {2,3} };       // creates dangling reference
   ```
   — *end example*]
-The fourth context is when a temporary object other than a function
-parameter object is created in the *for-range-initializer* of a
-range-based `for` statement. If such a temporary object would otherwise
-be destroyed at the end of the *for-range-initializer* full-expression,
-the object persists for the lifetime of the reference initialized by the
-*for-range-initializer*.
-The destruction of a temporary whose lifetime is not extended beyond the
-full-expression in which it was created is sequenced before the
-destruction of every temporary which is constructed earlier in the same
-full-expression. If the lifetime of two or more temporaries with
-lifetimes extending beyond the full-expressions in which they were
-created ends at the same point, these temporaries are destroyed at that
-point in the reverse order of the completion of their construction. In
-addition, the destruction of such temporaries shall take into account
-the ordering of destruction of objects with static, thread, or automatic
-storage duration
 [[basic.stc.static]], [[basic.stc.thread]], [[basic.stc.auto]]; that is,
 if `obj1` is an object with the same storage duration as the temporary
 and created before the temporary is created the temporary shall be
 destroyed before `obj1` is destroyed; if `obj2` is an object with the
 same storage duration as the temporary and created after the temporary

 ### Temporary objects <a id="class.temporary">[[class.temporary]]</a>
+A *temporary object* is an object created
+- when a prvalue is converted to an xvalue [[conv.rval]] and
 - when needed by the implementation to pass or return an object of
+ suitable type (see below).
 Even when the creation of the temporary object is unevaluated
 [[expr.context]], all the semantic restrictions shall be respected as if
 the temporary object had been created and later destroyed.
+[*Note 1*: This includes accessibility [[class.access]] and whether it
 is deleted, for the constructor selected and for the destructor.
 However, in the special case of the operand of a *decltype-specifier*
 [[dcl.type.decltype]], no temporary is introduced, so the foregoing does
 not apply to such a prvalue. — *end note*]
 The materialization of a temporary object is generally delayed as long
 as possible in order to avoid creating unnecessary temporary objects.
+[*Note 2*:
 Temporary objects are materialized:
 - when binding a reference to a prvalue
   [[dcl.init.ref]], [[expr.type.conv]], [[expr.dynamic.cast]], [[expr.static.cast]], [[expr.const.cast]], [[expr.cast]],
+- when performing certain member accesses on a class prvalue
   [[expr.ref]], [[expr.mptr.oper]],
+- when invoking an implicit object member function on a class prvalue
+  [[expr.call]],
 - when performing an array-to-pointer conversion or subscripting on an
   array prvalue [[conv.array]], [[expr.sub]],
 - when initializing an object of type `std::initializer_list<T>` from a
   *braced-init-list* [[dcl.init.list]],
 - for certain unevaluated operands [[expr.typeid]], [[expr.sizeof]], and
 materialized so that the reference parameter of `X::operator=(const X&)`
 can bind to it.
 — *end example*]
+When an object of type `X` is passed to or returned from a
+potentially-evaluated function call, if `X` is
+- a scalar type or
+- a class type that has at least one eligible copy or move constructor
+  [[special]], where each such constructor is trivial, and the
+  destructor of `X` is either trivial or deleted,
+implementations are permitted to create temporary objects to hold the
+function parameter or result object, as follows:
+- The first such temporary object is constructed from the function
+  argument or return value, respectively.
+- Each successive temporary object is initialized from the previous one
+  as if by direct-initialization if `X` is a scalar type, otherwise by
+  using an eligible trivial constructor.
+- The function parameter or return object is initialized from the final
+  temporary as if by direct-initialization if `X` is a scalar type,
+  otherwise by using an eligible trivial constructor.
+(In all cases, the eligible constructor is used even if that constructor
+is inaccessible or would not be selected by overload resolution to
+perform a copy or move of the object).
+[*Note 3*: This latitude is granted to allow objects to be passed to or
+returned from functions in registers. — *end note*]
+Temporary objects are destroyed as the last step in evaluating the
+full-expression [[intro.execution]] that (lexically) contains the point
+where they were created. This is true even if that evaluation ends in
+throwing an exception. The value computations and side effects of
+destroying a temporary object are associated only with the
+full-expression, not with any specific subexpression.
+Temporary objects are destroyed at a different point than the end of the
+full-expression in the following contexts: The first context is when a
+default constructor is called to initialize an element of an array with
+no corresponding initializer [[dcl.init]]. The second context is when a
+copy constructor is called to copy an element of an array while the
+entire array is copied
 [[expr.prim.lambda.capture]], [[class.copy.ctor]]. In either case, if
 the constructor has one or more default arguments, the destruction of
 every temporary created in a default argument is sequenced before the
 construction of the next array element, if any.
+The third context is when a reference binds to a temporary object.[^11]
 The temporary object to which the reference is bound or the temporary
 object that is the complete object of a subobject to which the reference
 is bound persists for the lifetime of the reference if the glvalue to
 which the reference is bound was obtained through one of the following:
                                             // exactly one of the two temporaries is lifetime-extended
 ```
 — *end example*]
+[*Note 4*:
 An explicit type conversion [[expr.type.conv]], [[expr.cast]] is
 interpreted as a sequence of elementary casts, covered above.
 [*Example 3*:
 — *end example*]
 — *end note*]
+[*Note 5*:
 If a temporary object has a reference member initialized by another
 temporary object, lifetime extension applies recursively to such a
 member’s initializer.
   containing the call.
 - A temporary object bound to a reference element of an aggregate of
   class type initialized from a parenthesized *expression-list*
   [[dcl.init]] persists until the completion of the full-expression
   containing the *expression-list*.
 - A temporary bound to a reference in a *new-initializer* [[expr.new]]
   persists until the completion of the full-expression containing the
   *new-initializer*.
+  \[*Note 6*: This might introduce a dangling reference. — *end note*]
   \[*Example 5*:
   ``` cpp
   struct S { int mi; const std::pair<int,int>& mp; };
   S a { 1, {2,3} };
   S* p = new S{ 1, {2,3} };       // creates dangling reference
   ```
   — *end example*]
+The fourth context is when a temporary object is created in the
+*for-range-initializer* of either a range-based `for` statement or an
+enumerating expansion statement [[stmt.expand]]. If such a temporary
+object would otherwise be destroyed at the end of the
+*for-range-initializer* full-expression, the object persists for the
+lifetime of the reference initialized by the *for-range-initializer*.
+The fifth context is when a temporary object is created in the
+*expansion-initializer* of an iterating or destructuring expansion
+statement. If such a temporary object would otherwise be destroyed at
+the end of that *expansion-initializer*, the object persists for the
+lifetime of the reference initialized by the *expansion-initializer*, if
+any.
+The sixth context is when a temporary object is created in a structured
+binding declaration [[dcl.struct.bind]]. Any temporary objects
+introduced by the *initializer*s for the variables with unique names are
+destroyed at the end of the structured binding declaration.
+Let `x` and `y` each be either a temporary object whose lifetime is not
+extended, or a function parameter. If the lifetimes of `x` and `y` end
+at the end of the same full-expression, and `x` is initialized before
+`y`, then the destruction of `y` is sequenced before that of `x`. If the
+lifetime of two or more temporaries with lifetimes extending beyond the
+full-expressions in which they were created ends at the same point,
+these temporaries are destroyed at that point in the reverse order of
+the completion of their construction. In addition, the destruction of
+such temporaries shall take into account the ordering of destruction of
+objects with static, thread, or automatic storage duration
 [[basic.stc.static]], [[basic.stc.thread]], [[basic.stc.auto]]; that is,
 if `obj1` is an object with the same storage duration as the temporary
 and created before the temporary is created the temporary shall be
 destroyed before `obj1` is destroyed; if `obj2` is an object with the
 same storage duration as the temporary and created after the temporary

Diff to HTML by rtfpessoa