Why is it illegal/immoral to reseat a reference? [duplicate]

Answer 1

Unlike pointers, references are designed to guarantee that they always refer to an object. To meet this gaurantee, the compiler requires that all references be initialized in their declaration and disallows you from reassigning them.

Similar to pointers, reference variables allow you to access the same instance of an object through multiple locations - but unlike pointers, reference provide a greater level of safety.

Answer 2

Because there is no syntax to do it:

int x = 0;
int y = 1;
int & r = x;

Now if I say:

r = y;

I assign the value of y to x. If I wanted to reseat I would need some special syntax:

r @= y;    // maybe?

As the main reason for using references is as parameters and return types of functions, where this is not an issue, it didn't seem to C++'s designers that this was a path worth going down.

Answer 3

Look at your code again:

temp = ref1;
ref2 = temp;
ref1 = ref2;

References are aliases. All operations that you do on the reference are performed on the object it references. In your code above, how should the compiler magically know that you aren't trying to assign the values to referenced variables, but are rather trying to change the reference itself? There's no syntax to indicate the difference between that, and, for example:

ref1 = 3;

which you'd normally expect to assign a value 3 to the object referenced by ref1.

In short, this is simply by design. If you want "reseatable" references, then you just use pointers (or, if you want to avoid accidential pointer arithmetic, boost::optional).

Answer 4

Because references don't have an address of their own (if they do that is implementation dependent, and you can't access them with the & operator directly).

The & operator is used to get the address of the thing that the reference is referring to.

Whereas a pointer does have an address of its own and you can access it with the & operator.

int x = 4;
int *p = &x;
//p holds the address of x
//&p holds the address of p.

int &r = x;
//&r holds the address of x

And if something doesn't have an address of its own then it can't store a value inside of it. And if it can't store a value inside of it, then it can't be changed.

I think the parashift C++ FAQ on references says it best:

Important note: Even though a reference is often implemented using an address in the underlying assembly language, please do not think of a reference as a funny looking pointer to an object. A reference is the object. It is not a pointer to the object, nor a copy of the object. It is the object.

and again in FAQ 8.5 :

Unlike a pointer, once a reference is bound to an object, it can not be "reseated" to another object. The reference itself isn't an object (it has no identity; taking the address of a reference gives you the address of the referent; remember: the reference is its referent).

Answer 5

A reference is an alias to object.
Alias can not be changed (we are not spies ;-)