White Wolf said:
shez said:
White Wolf wrote: [SNIP]
o.wrapper().foo().bar();
Of course it could be continued ad nauseam. I am 99% sure that the
temporary should live long enough, but... not 101%.
Could someone
help me out with the right answer... and - if possible - the chapter
and verse?
Temporaries are valid until the full expression has been completed. So
your code is perfectly safe.
That is what I know, but I was hoping for chapter and verse to support that
claim.
You asked for it!
======================================================================
ISO/IEC 14882:1998(E)
12.2 Temporary objects
1 Temporaries of class type are created in various contexts:
binding an rvalue to a reference (8.5.3), returning an rvalue
(6.6.3), a conversion that creates an rvalue (4.1, 5.2.9,
5.2.11, 5.4), throwing an exception (15.1), entering a handler
(15.3), and in some initializations (8.5). [Note: the lifetime
of exception objects is described in 15.1. ] Even when the
creation of the temporary object is avoided (12.8), all the
semantic restrictions must be respected as if the temporary
object was created. [Example: even if the copy constructor is
not called, all the semantic restrictions, such as accessibility
(clause 11), shall be satisfied. ]
2 [Example:
class X {
// ...
public:
// ...
X(int);
X(const X&);
~X();
};
X f(X);
void g()
{
X a(1);
X b = f(X(2));
a = f(a);
}
Here, 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. Also, a temporary might be
used to hold the result of f(X(2)) before copying it to b
using X’s copyconstructor; alternatively, f()’s result might
be constructed in b. On the other hand, the expression a=f(a)
requires a temporary for either the argument a or the result
of f(a) to avoid undesired aliasing of a. ]
3 When an implementation introduces a temporary object of a
class that has a nontrivial constructor (12.1), it shall
ensure that a constructor is called for the temporary object.
Similarly, the destructor shall be called for a temporary with
a nontrivial destructor (12.4). Temporary objects are destroyed
as the last step in evaluating the fullexpression (1.9) that
(lexically) contains the point where they were created. This is
true even if that evaluation ends in throwing an exception.
4 There are two contexts in which temporaries are destroyed at a
different point than the end of the fullexpression. The first
context is when an expression appears as an initializer for a
declarator defining an object. In that context, the temporary
that holds the result of the expression shall persist until the
object’s initialization is complete. The object is initialized
from a copy of the temporary; during this copying, an implementation
can call the copy constructor many times; the temporary is destroyed
after it has been copied, before or when the initialization completes.
If many temporaries are created by the evaluation of the initializer,
the temporaries are destroyed in reverse order of the completion of
their construction.
5 The second context is when a reference is bound to a temporary.
The temporary to which the reference is bound or the temporary
that is the complete object to a subobject of which the temporary
is bound persists for the lifetime of the reference except as
specified below. A temporary bound to a reference member in a
constructor’s ctorinitializer (12.6.2) persists until the con-
structor exits. A temporary bound to a reference parameter in a
function call (5.2.2) persists until the completion of the full
expression containing the call. A temporary bound to the returned
value in a function return statement (6.6.3) persists until the
function exits. In all these cases, the temporaries created during
the evaluation of the expression initializing the reference, except
the temporary to which the reference is bound, are destroyed at the
end of the fullexpression in which they are created and in the
reverse order of the completion of their construction. If the life-
time 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 or automatic
storage duration (3.7.1, 3.7.2); that is, if obj1 is an object with
static or automatic storage duration created before the temporary is
created, the temporary shall be destroyed before obj1 is destroyed; if
obj2 is an object with static or automatic storage duration created
after the temporary is created, the temporary shall be destroyed after
obj2 is destroyed. [Example:
class C {
// ...
public:
C();
C(int);
friend C operator+(const C&, const C&);
~C();
};
C obj1;
const C& cr = C(16)+C(23);
C obj2;
the expression C(16)+C(23) creates three temporaries. A first
temporary T1 to hold the result of the expression C(16), a
second temporary T2 to hold the result of the expression C(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, it is guaranteed
that T2 is 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, it is guaranteed that obj2 is destroyed before T3, and
that T3 is destroyed before obj1. ]
======================================================================
-Mike
