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();
}

--
Matthias Hofmann
Anvil-Soft, CEO
http://www.anvil-soft.com - The Creators of Toilet Tycoon
http://www.anvil-soft.de - Die Macher des Klomanagers

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]