Pointer and Memory from Stanford - c

Question

I am reading article from Stanford CS library http://cslibrary.stanford.edu/102/
Bad Pointer Example
Code with the most common sort of pointer bug will look like the above correct code, but without the middle step where the pointers are assigned pointees. The bad code will compile fine, but at run-time, each dereference with a bad pointer will corrupt memory in some way. The program will crash sooner or later. It is up to the programmer to ensure that each pointer is assigned a pointee before it is used. The following example shows a simple example of the bad code and a drawing of how memory is likely to react...
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}
// What happens at runtime when the bad pointer is dereferenced...
But I remember that char* should be defined like this
char *const name_ptr = "Test";
In this way, if everyone think about if this char* is a bad define?

Answer 1

The line
char *const name_ptr = "Test";
is fine; you're initializing the pointer with the address of the string literal "Test", which is an array of char stored in such a way that the memory for it is allocated at program startup and held until the program terminates.
A quick digression on the const qualifier:
In C, declaration of the form
const T foo = expr;
or
T const foo = expr;
means that foo may not be written to; it's assigned the value of expr when it's created, and that value may not be changed for the rest of foo's lifetime1). With pointer variables, it gets a little more complicated:
const T *p = expr;
T const *p = expr;
both declare p as a non-const pointer to const data; IOW, you can change the value of p (p can point to different objects), but not the value of *p (you cannot change the value of what p points to).
T * const p = expr;
declares p as a const pointer to non-const data; you can change the value of what p points to (*p = ...), but you cannot change p to point to a different object.
const T * const p = expr;
T const * const p = expr;
both declare p as a const pointer to const data; you cannot change either the value of p or what p points to.
In C, string literals such as "Test" are stored as arrays of char, but attempting to modify the contents of a string literal is undefined behavior (depending on the platform, you may get an access violation). For safety's sake, it's usually a good idea to declare pointers to string literals as const char * or char const *, rather than char * const as in the example above.
As far as
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}
is concerned, p is an auto variable, which is not initialized to any particular value; it will contain a random bit string that may or may not correspond to a writable address. Because of this, the behavior of the statement *p = 42; is undefined - you may get an access violation, you may wind up overwriting something important and leave the program in a bad state, or it may appear to "work" with no issues (writing to some random memory area that is accessible and not important).
In general, it's impossible to tell whether a given pointer value is valid or invalid from the pointer value alone2). The one exception is the special pointer value NULL, which is a well-defined "nowhere" that's guaranteed to compare unequal to any valid pointer value. Pointer variables declared at file scope (outside of any function) or with the static qualifier are implicitly initialized to NULL. Non-static, block-scope pointer variables should always be explicitly initialized with either NULL or a valid address. This way you can easily check to see if the pointer has been assigned a valid value:
int *p = NULL;
...
if (p != NULL) // or simply if (p)
{
*p = 42;
}
else
{
// p was not assigned a valid memory location
}
1) Note that, in C, foo is not a compile-time constant; it's a regular run-time variable, you just cannot write to it. You cannot use it in a context that requires a compile-time constant.
2) If you're intimately familiar with your platform's memory model you can make some educated guesses, but even then it's not guaranteed.

Answer 2

In the second case:
char *const name_ptr = "Test";
You are creating a string literal that placed in read-only memory. Therefore you can have a legit pointer to it.
In the first case:
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}
you will get an Undefined Behavior (UB).

Answer 3

char *const name_ptr means that name_ptr is a constant pointer to a char (it is the pointer which is constant).
You probably mean const char * name_ptr = "Test"
(name_ptr is a pointer to a character that is constant)
The thing is that "Test" is a string, which is an array of chars, stored somewhere in (probably) constant memory. Since the memory is allocated, then that is fine to initialise the pointer to point at it.
int *p; is an uninitialised pointer. It has some undefined value which might or might not resolve to a sensible memory location - odds are that it won't but you never know. Saying *p = 42; will overwrite that arbitary memory location with 42, then all bets for your program are off.

Answer 4

In a case like this, it helps to remember that a pointer is nothing more than a normal variable that holds a value - the only "magic" part about it is that value represents a location in memory, and you can dereference that location to access what's stored there.
Imagine a bit of code like this:
void BadPrinter() {
int p;
printf("%d\n", p);
}
What would it print? Who knows? Maybe 0, maybe garbage, maybe the lyrics to "Come Sail Away" by Styx encoded as an integer.
Now we go back to your pointer code:
void BadPointer() {
int* p; // allocate the pointer, but not the pointee
*p = 42; // this dereference is a serious runtime error
}
p is uninitialized in the exact same way - it could contain anything. So when you do *p, you're asking the compiler to give you access to whatever memory is represented by the number contained in p.
So if p happens to contain 0, you're now trying to stuff the value 42 into the memory location 0x0: your program will probably crash. If p happens to contain a location in writable memory, your program will probably continue merrily along, since you will be allowed to store 42 at that location.
Now this case is a little different:
char *const name_ptr = "Test";
Here you're asking the compiler to allocate enough memory space to store the string "Test" and store the location of that memory in name_ptr. Going back to our first example, it would be analogous to:
void GoodPrinter() {
int p = 4;
printf("%d\n", p);
}