Re: Understanding references
igor.kulkin@gmail.com wrote:
References is a relatively basic feature of C++ language.
It might be a good thing to think of references as aliases to the
variables.
However it's good to think of references this way when you deal with
references which are local variables.
But references can also be function arguments (in fact they are more
useful this way) in which case it has to have the in-memory
representation.
Today it just hit me that references are much like pointers in a way
the it's a variable that stores a pointer to a piece of memory. It's
just that the syntax of using references is a little bit different
from using pointers (we don't need to dereference (dereference is a
little bit misleading here. I mean indirection operator "*".) it each
time we want to access the value to which it points).
(BTW please correct if something of what I am saying is wrong. I've
realized that I don't understand references in C although I though I
did.)
So then I asked myself what would return an address-of operator ('&')
applied to a reference. A common sense tells me that it should
basically return a pointer to the value which is referenced. So in
fact it would then have exactly the same value that a reference
variable itself (in terms of in memory storage).
Right.
Then I question myself:
1) Is it true that in-memory representation of pointers and references
are the same (i.e. they both contain address to the value the
reference/point)?
Informally spoken, yes. As this is an implementation detail, we don't
need to care what the compiler is doing to implement the semantics.
Note that we don't need an in-memory representation of a reference if
the referenced object lives in the same scope as the reference:
int func ()
{
int a;
int& b = a;
int*c = &a;
}
The compiler will certainly reserve only two 16/32/64-bit locations on
the stack, one for variable a and one for c. As b is only an alias for
a, the compiler will certainly only put b in the symbol table, so that a
and b are assigned the same memory location (as pointed out above, this
is an implementation detail, so this information is only relevant for
knowing what happens behind the scenes).
2) If the answer to #1 is yes, is it possible to convert from
reference to pointer and vice versa without using "&" and "*"
operators (e.g. with reinterpret_cast)?
Nope. As the compiler may not have to reserve memory for a reference
(see above), this operation cannot simply be treated as a casting.
3) Is it true at all that an address-of operator applied to a
reference would return a pointer to a referenced value rather than a
pointer to a reference itself (a reference variable is stored
somewhere in the memory so it has to have its own address)?
Yes.
4) How can I get a pointer to the piece of memory which contains an
address stored in the reference (i.e. to the reference itself as a
contrast to a pointer to the value referenced by reference)?
AFAIK, you can't (as it is not guaranteed that the reference really
needs space like a pointer does).
Regards,
Stuart