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

Files changed (1) hide show

tmp/tmpuvyl2cg0/{from.md → to.md} +89 -42

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

@@ -1,22 +1,51 @@
 ## Temporary objects <a id="class.temporary">[[class.temporary]]</a>
-Temporaries of class type are created in various contexts: binding a
-reference to a prvalue ([[dcl.init.ref]]), returning a prvalue (
-[[stmt.return]]), a conversion that creates a prvalue ([[conv.lval]],
-[[expr.static.cast]], [[expr.const.cast]], [[expr.cast]]), throwing an
-exception ([[except.throw]]), and in some initializations (
-[[dcl.init]]). The lifetime of exception objects is described in
-[[except.throw]]. Even when the creation of the temporary object is
-unevaluated (Clause  [[expr]]) or otherwise avoided ([[class.copy]]),
-all the semantic restrictions shall be respected as if the temporary
-object had been created and later destroyed. This includes
-accessibility ([[class.access]]) and whether it is deleted, for the
-constructor selected and for the destructor. However, in the special
-case of a function call used as the operand of a *decltype-specifier* (
-[[expr.call]]), no temporary is introduced, so the foregoing does not
-apply to the prvalue of any such function call.
 Consider the following code:
 ``` cpp
 class X {
@@ -43,24 +72,34 @@ void h() {
   Y c = g(Y(3));
   a = f(a);
 }
 ```
-An implementation might use a temporary in which to construct `X(2)`
-before passing it to `f()` using `X`’s copy constructor; alternatively,
-`X(2)` might be constructed in the space used to hold the argument.
-Likewise, an implementation might use a temporary in which to construct
-`Y(3)` before passing it to `g()` using `Y`’s move constructor;
-alternatively, `Y(3)` might be constructed in the space used to hold the
-argument. Also, a temporary might be used to hold the result of
-`f(X(2))` before copying it to `b` using `X`’s copy constructor;
-alternatively, `f()`’s result might be constructed in `b`. Likewise, a
-temporary might be used to hold the result of `g(Y(3))` before moving it
-to `c` using `Y`’s move constructor; alternatively, `g()`’s result might
-be constructed in `c`. On the other hand, the expression `a=f(a)`
-requires a temporary for the result of `f(a)`, which is then assigned to
-`a`.
 When an implementation introduces a temporary object of a class that has
 a non-trivial constructor ([[class.ctor]], [[class.copy]]), 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
@@ -70,42 +109,46 @@ last step in evaluating the full-expression ([[intro.execution]]) that
 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 two 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. 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 second context is when a reference is bound to a temporary.[^1] The
 temporary to which the reference is bound or the temporary that is the
 complete object of a subobject to which the reference is bound persists
 for the lifetime of the reference except:
-- A temporary bound to a reference member in a constructor’s
-  *ctor-initializer* ([[class.base.init]]) persists until the
-  constructor exits.
-- A temporary bound to a reference parameter in a function call (
   [[expr.call]]) persists until the completion of the full-expression
   containing the call.
 - 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*.
   ``` 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
   ```
- This may introduce a dangling reference, and implementations are
- encouraged to issue a warning in such a case.
 The destruction of a temporary whose lifetime is not extended by being
 bound to a reference 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 to which references are bound
@@ -119,10 +162,12 @@ 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 is created the temporary shall be destroyed
 after `obj2` is destroyed.
 ``` cpp
 struct S {
   S();
   S(int);
   friend S operator+(const S&, const S&);
@@ -149,5 +194,7 @@ order in which `T3` is destroyed takes into account the destruction
 order of other objects with static storage duration. That is, because
 `obj1` is constructed before `T3`, and `T3` is constructed before
 `obj2`, `obj2` shall be destroyed before `T3`, and `T3` shall be
 destroyed before `obj1`.

 ## Temporary objects <a id="class.temporary">[[class.temporary]]</a>
+Temporary objects are created
+- when a prvalue is materialized so that it can be used as a glvalue (
+ [[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 (Clause
+[[expr]]), all the semantic restrictions shall be respected as if the
+temporary object had been created and later destroyed.
+[*Note 2*: This includes accessibility (Clause  [[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* ([[expr.call]]), 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
+- when a prvalue appears as a discarded-value expression (Clause
+  [[expr]]).
+— *end note*]
+[*Example 1*:
 Consider the following code:
 ``` cpp
 class X {
   Y c = g(Y(3));
   a = f(a);
 }
 ```
+`X(2)` is constructed in the space used to hold `f()`’s argument and
+`Y(3)` is constructed in the space used to hold `g()`’s argument.
+Likewise, `f()`’s result is constructed directly in `b` and `g()`’s
+result is constructed directly in `c`. On the other hand, the expression
+`a = f(a)` requires a temporary for the result of `f(a)`, which is
+materialized so that the reference parameter of `A::operator=(const A&)`
+can bind to it.
+— *end example*]
+When an object of class type `X` is passed to or returned from a
+function, if each copy constructor, move constructor, and destructor of
+`X` is either trivial or deleted, and `X` has at least one non-deleted
+copy or move constructor, 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 non-deleted 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.ctor]], [[class.copy]]), 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
 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 three 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]]). 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 is bound to a temporary.[^1] The
 temporary to which the reference is bound or the temporary that is the
 complete object of a subobject to which the reference is bound persists
 for the lifetime of the reference except:
+- A temporary object bound to a reference parameter in a function call (
   [[expr.call]]) persists until the completion of the full-expression
   containing the call.
 - 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*.
+  \[*Example 2*:
   ``` 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*]
+ \[*Note 5*: This may introduce a dangling reference, and
+  implementations are encouraged to issue a warning in such a
+  case. — *end note*]
 The destruction of a temporary whose lifetime is not extended by being
 bound to a reference 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 to which references are bound
 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 is created the temporary shall be destroyed
 after `obj2` is destroyed.
+[*Example 3*:
 ``` cpp
 struct S {
   S();
   S(int);
   friend S operator+(const S&, const S&);
 order of other objects with static storage duration. That is, because
 `obj1` is constructed before `T3`, and `T3` is constructed before
 `obj2`, `obj2` shall be destroyed before `T3`, and `T3` shall be
 destroyed before `obj1`.
+— *end example*]

Diff to HTML by rtfpessoa