15 Special member functions [special]

15.2 Temporary objects [class.temporary]

Temporary objects are created

(1.1)
when a prvalue is materialized so that it can be used as a glvalue ([conv.rval]),
(1.2)
when needed by the implementation to pass or return an object of trivially-copyable type (see below), and
(1.3)
when throwing an exception ([except.throw]).

[ Note
:
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

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

Temporary objects are materialized:

(2.1)
when binding a reference to a prvalue ([dcl.init.ref], [expr.type.conv], [expr.dynamic.cast], [expr.static.cast], [expr.const.cast], [expr.cast]),
(2.2)
when performing member access on a class prvalue ([expr.ref], [expr.mptr.oper]),
(2.3)
when performing an array-to-pointer conversion or subscripting on an array prvalue ([conv.array], [expr.sub]),
(2.4)
when initializing an object of type std::initializer_list<T> from a braced-init-list ([dcl.init.list]),
(2.5)
for certain unevaluated operands ([expr.typeid], [expr.sizeof]), and
(2.6)
when a prvalue appears as a discarded-value expression (Clause [expr]).

— end note

]

[ Example

Consider the following code:

class X {
public:
  X(int);
  X(const X&);
  X& operator=(const X&);
  ~X();
};

class Y {
public:
  Y(int);
  Y(Y&&);
  ~Y();
};

X f(X);
Y g(Y);

void h() {
  X a(1);
  X b = f(X(2));
  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

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 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 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.116

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:

(6.1)
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.
(6.2)
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.
(6.3)
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
:
```
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
:
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 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 temporaries bound to references 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 is created the temporary shall be destroyed after obj2 is destroyed.

[ Example

struct S {
  S();
  S(int);
  friend S operator+(const S&, const S&);
  ~S();
};
S obj1;
const S& cr = S(16)+S(23);
S obj2;

the expression S(16) + S(23) creates three temporaries: a first temporary T1 to hold the result of the expression S(16), a second temporary T2 to hold the result of the expression S(23), and a third temporary T3 to hold the result of the addition of these two expressions.

The temporary T3 is then bound to the reference cr.

It is unspecified whether T1 or T2 is created first.

On an implementation where T1 is created before T2, T2 shall be destroyed before T1.

The temporaries T1 and T2 are bound to the reference parameters of operator+; these temporaries are destroyed at the end of the full-expression containing the call to operator+.

The temporary T3 bound to the reference cr is destroyed at the end of cr's lifetime, that is, at the end of the program.

In addition, the 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.

— end example

]

116)

The same rules apply to initialization of an initializer_list object ([dcl.init.list]) with its underlying temporary array.