Re: Reference to void
Gerhard Menzl wrote:
Greg Herlihy wrote:
The following is a "reference to const":
const int i = 3;
const int& iRefConst = i;
and differs from the original example significantly: namely iRefConst
has an immutable value whereas iRef does not.
Then what is ref in
void f(int const& ref);
int my_rand();
void g()
{
int i = 1;
int const ci = 2;
f(my_rand() % 2 ? i : ci);
}
- a reference to const or a reference to non-const? You cannot tell, as
it depends on runtime conditions. Since this is about terminology for
static types, your distinction is meaningless.
When bound to the 2, ref is a "reference to const", when bound to ci,
it is a "reference to a non-const". So on every call to f(), ref is
consistently claiming that its bound object is const - even though we
know that at least on some of the calls, that claim is false. So rather
than buy wholeheartedly into ref's claims, we should stick to what we
know and attribute the "const" to its source - the declaration of ref
itself. So f()'s ref paramter is a "const reference" and we leave the
question of the object's actual const-ness unspecified (unless it can
be determined for certain).
We should do so because there is one thing that we can be sure of: is
that there is another, direct declaration for the ref's object
somewhere else in the program - a declaration that really determines
the constness of object. And ref's own declaration does not affect the
declaration for the actual object. So we should reserve "reference to
const" when we know that the referenced object is const, and use "const
reference" as the shorthand for "a reference to a (supposedly) const
object".
Whether ref's object is actually declared const or not is far from a
meaningless distinction. On the contrary, it directly affects whether
it is safe to cache ref's value or not. And the distinction exists -
whether or not we choose to acknowledge it or nor, or even whether we
can determine it in a particular case. The choice is between a richer
vocabulary that is capable of expressing the difference, rather than a
watered-down terminology that cannot.
Does 2/3 equal 3/2 because 2 * 3 equals 3 * 2 ? No, because using
multiplication to demonstrate a point about division is just as
effective as using pointers to prove a point about references.
Just as a point about arithmetics cannot be used to prove a point about
indirection.
Pointers use indirection, references use aliasing. A pointer does not
claim to be the object that it points to. A pointer to an int is not an
int. A reference on the other hand makes exactly that claim: a
reference to an int is an int. A reference to a const int is a const
int. Whereas a const reference to an int is only an int object
pretending (under an assumed name) to be const. It should be possible
to express in words all three types of references.
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]