为什么对整数的右值引用是合法的

Question

This might be a dumb question about C++11 but it really bothers me.

As my understanding, rvalue reference is also a reference, which means that it will algo point to some variable, just like the reference does.

For example,

const int &ref = 1;

The reference ref points to the pure rvalue 1 , which can't be modified, that's why the compiler force us to use const .

Another example,

Bar&& GetBar()
{
    Bar b;
    return std::move(b);
}

This function will return a dangling reference because b is destructed after return ing.

In a word, rvalue reference is algo a reference.

Now I'm confused. Please check the following code:

int &&rref = 1;

If rvalue reference is also a reference, so rref now points to the pure rvalue 1 , which shouldn't be compilable as my understanding, because if it's compilable, what if I execute rref = 2 ? Does this mean that the pure rvalue is changed: 1 becomes 2 ?

But gcc told me that it was compilable...

Why? Why don't we need const int &&rref = 1 ?

Answer 1

A quote from cppreference

The lifetime of a temporary object may be extended by binding to a const lvalue reference or to an rvalue reference (since C++11), see reference initialization for details.

With a link to additional details here

Whenever a reference is bound to a temporary or to a subobject thereof, the lifetime of the temporary is extended to match the lifetime of the reference, with the following exceptions:

It then goes on to list a few exceptions like

a temporary bound to a return value of a function in a return statement is not extended: it is destroyed immediately at the end of the return expression. Such function always returns a dangling reference.

a temporary bound to a reference member in a constructor initializer list persists only until the constructor exits, not as long as the object exists. (note: such initialization is ill-formed as of DR 1696). (until C++14)

a temporary bound to a reference parameter in a function call exists until the end of the full expression containing that function call: if the function returns a reference, which outlives the full expression, it becomes a dangling reference.

a temporary bound to a reference in the initializer used in a new-expression exists until the end of the full expression containing that new-expression, not as long as the initialized object. If the initialized object outlives the full expression, its reference member becomes a dangling reference. (since C++11)

a temporary bound to a reference in a reference element of an aggregate initialized using direct-initialization syntax (parentheses) as opposed to list-initialization syntax (braces) exists until the end of the full expression containing the initializer. (since C++20)

So the reasoning that

const int &ref = 1;

works since we use const is not true. The compiler is actually extending the lifetime of the temporary object to match the lifetime of the reference. So it's equally valid to do the same thing with an rvalue reference.

On the other hand

int &ref = 1;

would not make sense since 1 is not an lvalue. That's why we need const or an rvalue reference.