Question

Consider the following code dealing with const references:

const int & func (const int &x)
{
    return x;
}

struct Foo {
    Foo (const int &x)
    : m_x(x) {}

    const int & getX ()
    { return m_x; }

    const int &m_x;
};

I’d like to know which, if any, of the following is now allowed:

int x = func(int(7));
int y = Foo(int(7)).getX();

Is there any guarantee that the temporary int object still exists before it is used by the assignment or getX?.

UPDATE: So it appears this is safe – but why exactly?

1. Is it because temporaries bind to const references recursively and are guaranteed to exist as long as of those bound references to them exists?
2. Or is it because they are guaranteed to exist for the duration of the full expression?

Consider the edge case which stores a pointer instead of a reference:

struct Foo {
    Foo (const int &x)
    : m_x(&x) {}

    const int & getX ()
    { return *m_x; }

    const int *m_x;
};

int y = Foo(int(7)).getX();

It seems that if case 1) was correct, this would not work. But if case 2) was correct, it would.

Answer 1

Both are safe, because you copy the values into x and y. The temporaries are valid until the end of the full expression.

12.2 Temporary objects

4) 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, any
temporaries created in the default argument expressions are destroyed
immediately after return from the constructor.

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 of a
subobject to which the reference is bound persists for the lifetime of
the reference except as specified below. A temporary bound to a
reference member in a constructor’s ctor-initializer (12.6.2) persists
until the constructor 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 full-expression in which they are created and in the
reverse order of the completion of their construction. 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 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.
—end example ]