In the "C++ programming language", there is an example
void g()
{
int ii = 0;
int& rr = ii;
rr++;
int* pp = &rr;
}
The author states:
This is legal, but rr++ does not increment the reference rr, rather, ++ is applied to an int that happens to be ii.
I am quite confusing about this statement, why "rr++ does not increment the reference rr"? So rr is just used as "bridge" to increment ii?
Yes, in C++ a reference is nothing more than an alias, or a "bridge" as you say. Any time you say rr, it is as if you'd said ii, the "original" name of the variable that rr references.
That is different from references in many other languages (which behave more like C++'s pointers). In C++, references are not objects, they have no separate identity. You can't tell the reference to "please increment", or "please point to null" or anything else. It just becomes another name for the variable that the reference points to.
A reference is similar to a dereferenced pointer to a variable. For example:
int v = 3;
int* pv = &v;
int& rv = v;
// Access v through a pointer:
*pv = 4;
// Access v through a reference:
rv = 4;
In this example, both statements will set v to 4.
So rr is just used as "bridge" to increment ii?
Exactly. Internally, it would store an address of ii and the compiler would increment the int at this address. Can be used for eg.:
int left, right;
...
int &direction = random_bool() ? left : right;
++direction; // would change left or right, depending on random_bool()
but is mostly used in function parameters and return types.
ii’s value directly.
ii initially 1 instead of 0) and it could even eliminate the ii variable altogether. A good optimizing compiler will surely do all of these, turning g() into a no-op. However, this says nothing about the behavior of references.It increments ii, it does not increment an address that is contained in rr.
rris not an object in its own right, but merely an alternate name for some other, pre-existing object. So operations cannot be performed onrritself, but rather the other object to which it refers. In this case,rr++;is identical in effect to whatii++;would have been.rris an alternate name for another preexisting object is IMO more confusing because it just doesn't fit how things work. A reference is not another name, but it is its own entity. For exampleint &r = *new int; delete &r;after this,rstill exists, the object it referred to doesn't exist anymore. The reference has a name, it is not a name itself.