Why does the compiler allow a function to return a value that is stored as a reference

Question

Can anybody explain why this code does not generate a compiler error?

class Foo
{
   public:
      int _x;
};

Foo getFoo()
{
   Foo myfoo;
   myfoo._x = 10;
   return myfoo;
}


int _tmain()
{
   // shouldn't this line of code be a compiler error?
   Foo& badfoo = getFoo();

   return 0;
}

Answer 1

No. getFoo() returns a value, this means that a temporary copy of it will be allocated, and the reference will refer to that copy.

Answer 2

You can bind references to temporaries, and they have the lifetime of the reference itself.

If on the other hand getFoo returned Foo&, you'd have some problems because the lifetime of the object would end when the getFoo function ended. Since you're not returning a reference to internal data but rather returning a copy of that data, you're fine.

Answer 3

The getFoo method could also be like this:

 Foo getFoo() 

{
   Foo* myfoo = new Foo();
   myfoo->_x = 10;
   return *myfoo;
}

And this is OK... The compiler can't know everything :)

Answer 4

This should be a compile error, although it would not be if it were instead

const Foo& badfoo = getFoo();

Since there is a special rule that extends the lifetime of temporary values bound to constant references, but only to constant references, not any reference.

The code you posted gives me the expected compile error of

error: invalid initialization of non-const reference of type ‘Foo&’ from a temporary of type ‘Foo’

on G++ 4.3.2. Which compiler are you using?

Answer 5

You are probably using VC++ which allows this as an extension.

main.cpp:18: warning C4239: nonstandard extension used : 
'initializing' : conversion from 'Foo' to 'Foo &'