为什么“最重要的const”必须是const？

Question

In http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/ it mentions "most important const" where by C++ deliberately specifies that binding a temporary object to a reference to const on the stack lengthens the lifetime of the temporary to the lifetime of the reference itself. I was wondering why c++ only allows the lifetime of the object to be lengthened when the reference is const and not when it isn't? What is the rational behind the feature and why does it have to be const?

Answer 1

Here's an example:

void square(int &x)
{
  x = x * x;
}

int main()
{
  float f = 3.0f;

  square(f);

  std::cout << f << '\n';
}

If temporaries could bind to non-const lvalue references, the above would happily compile, but produce rather surprising results (an output of 3 instead of 9 ).

Answer 2

Consider the following:

int& x = 5;
x = 6;

What should happen if this was allowed? By contrast, if you did

const int& x = 5;

there would be no legal way to modify x .

Answer 3

Note that const references can be bound to objects that don't even have an address normally. A const int & function parameter can take an argument formed by the literal constant expression 42 . We cannot take the address of 42 , so we cannot pass it to a function that takes a const int * .

const references are specially "blessed" to be able to bind to rvalues such as this.

Of course, for traditional rvalues like 2 + 2 , lifetime isn't an issue. It's an issue for rvalues of class type.

If the binding of a reference is allowed to some object which, unlike 42 , does not have a pervasive lifetime, that lifetime has to be extended, so that the reference remains sane throughout its scope.

It's not that the const causes a lifetime extension, it's that a non-const reference is not allowed. If that were allowed, it would also require a lifetime extension; there is no point in allowing some reference which then goes bad in some parts of its scope. That behavior undermines the concept that a reference is safer than a pointer.