Binding rvalue to const lvalue reference

Question

For some reason I didn't manage to find this exact question. Why is it allowed to bind an rvalue to const lvalue reference, although it is impossible to to the same without the const?

I do understand that the lifetime of the rvalue gets an extension somehow (in the first case) , but if so, why would the compiler disallow changing that 'rvalue', which is not really a temporary object anymore.

For example, consider the following code:

int main(){
   int &i=3; //produces error
   const int&j =3; //compiles
   return 1;
}

Answer 1

You may find the following article useful:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1993/N0345.pdf

I might be entirely wrong here, but this is how I rationalise it. An rvalue is constant, it cannot be changed. you cannot change the integer 5, fact. So when you bind the references the lvalue will have to be const. Otherwise your compiler will throw an error:

obj & a1 = bar();

invalid initialization of non-const reference of type ‘obj&’ from an rvalue of type ‘obj’

using g++

The only way to safely bind an rvalue to an lvalue is either by marking the lvalue as const, or using a mutable rvalue reference && (introduced in C++11 believe?)

struct obj {
};

obj bar() {
    obj x;
    return x;
}

int main() {
const obj & a1 = bar();
obj && a2 = bar();
return 0;
};

Answer 2

If you're asking about

void f(const int&);
f(1);

versus

void g(int&);
g(1);

the answer is to think about what happens if g looks like this:

void g(int& r) {
    ++r;
}