Lifetime of temporaries

Question

Below code shows lifetime of object created in function create() is extended to the life time of const ref created in main, is this correct in all cases? I mean we can extend the life time of temporary in certain cases by creating a reference to it? Or in this specific case the compiler is misbehaving?

It is compiled with MSVC2005

#include <iostream>

class testClass
{
public:
    testClass()
    {
        std::cout << "in testClass " << ((void*)this) << std::endl;
    }

    ~testClass()
    {
        std::cout << "in ~testClass " << ((void*)this) << std::endl;
    }
};


testClass create()
{
    return testClass();
}


int main()
{
    {
        testClass const& obj = create();

        std::cout << "we got a const reference to obj " << ((void*)&obj) << std::endl;
    }

    return 0;
}

Output

in testClass 0018FF13
we got a const reference to obj 0018FF13
in ~testClass 0018FF13

Of course other may get different addresses...In above case i was expecting destructor for the object created with function create(), will be called before line

std::cout << "we got a const reference to obj " << ((void*)&obj) << std::endl; 

is executed.

Answer 1

This is a special case: binding a const reference to a temporary object, stretches its lifetime until that const reference goes out of scope. This is only true for function local const references, e.g. the following will not work:

struct X
{
  int const& i
  X(int const& i_) : i(i_) {}
};

int f();

int main()
{
  X x(f()); 
  int u = x.i; //!
}

During construction of x, the i_ will be bound to the temporary returned by f, as will i, but although it's a const reference, that temporarie's lifetime will not be stretched to that of i, i.e. the rule does apply here.

See this GOTW article

Update: as is mentioned in the article and in the comments, the const is vital. The C++ standard allows binding of temporaries only to const lvalue references and rvalue references, so int& i = f(); is not allowed. However, MSVC has an extension that allows this, and as with other references, the lifetime of the temporary is extended until the reference goes out of scope. I would not recommend to exploit that extension, as it makes the code nonportable. In fact, I would be careful binding temporaries to references, since this feature is not well known and your colleagues might be baffled seeing it work, which means the code will lack readability.

Answer 2

To clarify - We can show 3 scenarios for testClass create():

1

Returning a copy but catching it by const reference

testClass create()
{
    return testClass();
}

testClass const &obj = create();

It extends the life time of temporary testClass() as long as obj.

 

2

Returning a copy and catching it by assignment (RVO)

testClass create()
{
    return testClass();
}

testClass obj = create();

It extends the life time of temporary testClass() as long as obj, because RVO implicitly applies on it. It'd better to say, in fact there is no temporary object here, all things operate on obj even in create() function.

 

3

Returning a copy and catching it by assignment (without RVO)

testClass create()
{
    return testClass();
}

testClass obj = create();

The life time of temporary testClass() exceeds after returning from create(), and a new object comes to world.

Answer 3

This link should help you to understand how this situation is qualified.

When a temporary object is created to initialize a reference variable, the name of the temporary object has the same scope as that of the reference variable. When a temporary object is created during the evaluation of a full-expression (an expression that is not a subexpression of another expression), it is destroyed as the last step in its evaluation that lexically contains the point where it was created.

There are two exceptions in the destruction of full-expressions:

• The expression appears as an initializer for a declaration defining an object: the temporary object is destroyed when the initialization is complete.
• A reference is bound to a temporary object: the temporary object is destroyed at the end of the reference's lifetime.