Question

I’m currently going over pointers in class and our textbook is confusing me a little bit. They start off by saying that following example copies the value in the place pointed to by money into the place pointed to by myMoney:

*myMoney = *money;

Then the next example copies the value in money into myMoney

myMoney = money;

This second example causes a memory leak because the original location that *myMoney pointed is no longer accessible. Is this because the memory that used to hold the pointer is now an actual float value instead of a memory address?

Now the part that confuses me a little is in the next part when they are showing a different declaration. Full example:

char alpha[20];
char *alphaPtr;
char *letterPtr;
vod Process(char []);
.
.
alphaPtr = alpha;
letterPtr = &alpha[0];
Process(alpha);

Since the book says that

myMoney = money;

will create a memory leak because it severs the link between the pointer and it’s pointed to address, will

alphaPtr = alpha;

cause a memory link also? Shouldn’t they have declared it like

char *alphaPtr = *alpha;

Answer 1

Things to remember:

• myMoney and money are pointers, so myMoney = money; copies one pointer over another. Now you have two pointers pointing at the same thing (what money pointed to), and nothing pointing at what myMoney used to point at (this is a memory leak).
• *myMoney and *money are the values pointed to by the pointers (because * dereferences a pointer to get what it’s pointing to), so *myMoney = *money; copies what money points to over what myMoney points to; the pointers themselves did not change.
• alpha is an array, which can be degraded into a pointer to the first element in the array.
• There’s no leak with alphaPtr because it wasn’t pointing to anything in the first place.
• Yes, char *alphaPtr = *alpha; Would have been a much better way to write it, because then alphaPtr doesn’t spend any time uninitialized. Some compilers will even warn you when you declare uninitialized pointers like the textbook example.
• Using (dereferencing) an uninitialized pointer is a bad thing as it results in dreaded undefined behavior. Your program may crash immediately, or it may crash much later, or it may simply corrupt your data without telling you anything, and you’ll only find it months later, if ever.