JKop wrote:
Karl Heinz Buchegger posted:
JKop wrote:
John Harrison posted:
From the practical point of view there is the fact that a const
reference can bind to a temporary, something a pointer cannot do.
int Monkey(void) { return 42; }
void Parrot(int* pBeak)
{
std:: cout << *pBeak;
}
int main(void)
{
int* k;
If you don't initialize k, where does k reside and what is the value at
that location?
For sake of argument, let's assume it resides at 0x80808080.
Ok, now, how about the value for k? Well, k is 4 bytes long and we know
it starts at 0x80808080 ... so, its going to be random, right? Lets just
say the 4 bytes starting from address 0x80808080 are 0xaabbccdd. Again,
what I'm referring to here is the random bit pattern that exists at the
address in memory where k resides.
Parrot( &( *k = Monkey() ) );
Now, assume this works as you think, where does the value '42' get written?
assuming k resides at memory address 0x80808080
and the value of k = 0xaabbccdd
then ----> the operating system jumps to address
0xaabbccdd and writes the value 0x0000002a.
Notice, the location where k resides hasn't changed ... and the actual
bit pattern at that location didn't change. Your code will change the
bits at the random address that k is holding or pointing to.
So, we agree that the value of k is random right? What if the bit
pattern at address 0x80808080 is 0x00000000 or NULL. We don't know? It
could be. There's no of any value.
So try this:
int* k = 0;
In this case, *k* is validly declared - and so, let us assume it still
resides at address 0x80808080. But this time, we assigned a value to the
4 bytes. The 4 bytes from 0x80808080 ~ 0x80808084 will be 0x00000000.
Now try:
*k = 5;
What do you get? Sure, it compiles fine. It won't run. Why not? Well, it
just so happens that NULL or 0x0 is an address that cannot be written to.
So, in your example, if the value of k at address 0x80808080 equals NULL
or 0x00000000, what will happen when you try to write the value 42 to *k.
Do you understand what happens when you dereference a pointer? The value
is not written to the location the pointer exists in memory - it is
written to the place the pointer _points-to_ in memory. In this example,
we are trying to write the value '42' to the address location 0x00000000
and that will break.
Take this example and extend it. Imagine a memory address too large.
Imagine a memory address already in use in the system. Remember, the
bits at k are going to be random ...
Your example as its written, isn't really about temporaries. Its about
dangling pointers.
This question actually goes back to when you didn't agree with Julie
that dangling pointers are _bad_. When one dereferences a dangling
pointer, its possible they may point to memory that the compiler is
happily using for other things. Writing, reading, etc. If you try to
access memory with a dangling pointer, you're not going to necessarily
break anything - but you can't depend on anything being there ... since
the operating system is tracking and using memory like a mad man.
And if you write to a dangling pointer - you might be overwriting
something the OS just put there. Or, you might be writing to a blank
area - or you might be writing to NULL (which would throw an exception).
Maybe _bad_ isn't the word, but the resulting behavior is unpredictable
if you tried to write or read from a dangling pointer -- and therefore,
it is undefined.
Hth,
-Luther
(If all this pointer talk is confusing, try reading K&R or some other C
text).
