Is the lifetime of a reference extended?

Question

I'd like to pass a reference into a function. This code does not work, as I'd expect:

struct A {
};

void foo(A& a) {
    // do something with a
}

int main(int, char**) {
    foo(A());
}

I get the compile error

invalid initialization of non-const reference of type A& from an rvalue of type A

But when I just add the method A& ref() to A like below and call it before passing it along, it seems I can use a. When debugging, the A object is destroyed after foo() is called:

struct A {
    A& ref() {
        return *this;
    }
};

void foo(A& a) {
    // do something with a
}

int main(int, char**) {
    foo(A().ref());
}

Is this valid code according to the standard? Does calling ref() magically extend the lifetime of the object until foo() returns?

Answer 1

Your code is perfectly valid.

In this line

foo(A().ref());

The instance of a temporary A lives until the end of the statement (;).

That's why it's safe to pass A& returned from ref() to foo (as long as foo doesn't store it).

ref() by itself does not extend any lifetime, but it helps by returning an lvalue reference.

What happens in the case of foo(A()); ? Here the temporary is passed as an rvalue. And in C++ an rvalue does not bind to non-const lvalue references (even in C++11, an rvalue reference does not bind to non-const lvalue references).

From this Visual C++ blog article about rvalue references:

... C++ doesn't want you to accidentally modify temporaries, but directly calling a non-const member function on a modifiable rvalue is explicit, so it's allowed ...