Re: Lifetime of a temporary that is bound to a reference

Hello,

I vaguely remember that when a temporary is bound to a reference, the
lifetime of the temporary is at least as long as that of the reference.
I would like to know how this is defined in the following case:

const int& min( const int& a, const int& b ) { return a < b ? a : b; }

int f() { return 42; }

int main()
{
     int i = min( f(), int() );

     return 0;
}

In the example above, two temporaries are bound to the formal parameters
of min(). One of these parameters is then bound to the return value of
the function, which is then used to assign a value to 'i'. I believe
that this code is well defined, but I would like to know why. Is there a
guarantee that the temporaries will not have gone out of scope by the
time 'i' is assigned its value? I guess that the lifetime of the
temporaries depends on the lifetime of the formal parameters of min()?

But if this code is well defined, then how come the following isn't:

#include <iostream>

class Foo
{
     const int& m_value;

public:
     Foo( const int& value ) : m_value( value ) {} void f() { std::cout
     << m_value << std::endl; }
};

Foo x( 42 );

int main()
{
     // Output is "1" on VC++
     // 2005 Express Edition.
     x.f();
}