Dtyjlui

Still learning more C and am a little confused. In my references I find cautions about assigning a pointer that has not been initialized. They go on to give examples. Great answers yesterday by the way from folks helping me with pointers, here:

Precedence, Parentheses, Pointers with iterative array functions

On follow up I briefly asked about the last iteration of the loop and potentially pointing the pointer to a non-existent place (i.e. because of my references cautioning against it). So I went back and looked more and find this:

If you have a pointer

int *pt;

then use it without initializing it (i.e. I take this to mean without a statement like *pt= &myVariable):

*pt = 606;

you could end up with a real bad day depending on where in memory this pointer has been assigned to. The part I'm having trouble with is when working with a string of characters something like this would be ok:

char *str = "Sometimes I feel like I'm going crazy.";

Where the reference says, "Don't worry about where in the memory the string is allocated; it's handled automatically by the compiler". So no need to say initialize *str = &str[0]; or *str = str;. Meaning, the compiler is automatically char str[n]; in the background?

Why is it that this is handled differently? Or, am I completely misunderstanding?

Simplifying the string literal can be expressed as:

const char literal = "Sometimes I feel like I'm going crazy."

so the expression

char *str = "Sometimes I feel like I'm going crazy.";

is logically equivalent to:

const char literal = "Sometimes I feel like I'm going crazy."

char *str = literal;

of course literals do not have the names

But you can't deference the char pointer which does not have allocated memory for the actual object

/* Wrong */

char *c;

*c = 'a';

/* Wrong  - you assign the pointer with the integer value */ 

char *d = 'a';



/* Correct  */

char *d = malloc(1);

*d = 'a';



/* Correct */

char x

char *e = &x;

*e = 'b';

The last example.

/* Wrong - you assign the pointer with the integer value */

int *p = 666;



/* Wrong oyu dereference the pointer which references to the not allocated space */

int *r;

*r = 666;



/* Correct */

int *s = malloc(sizeof(*s));

*s = 666;



/* Correct */

int t;

int *u = &t;

*u = 666;

And the last one - something similar to the string literals = the compound literals

/* Correct */

int *z = (int){666,567,234};

z[2] = 0;

*z = 5;



/* Correct */

int *z = (const int){666,567,234}; 

In this case:

char *str = "Sometimes I feel like I'm going crazy.";

You're initializing str to contain the address of the given string literal. You're not actually dereferencing anything at this point.

This is also fine:

char *str;

str = "Sometimes I feel like I'm going crazy.";

Because you're assigning to str and not actually dereferencing it.

This is a problem:

int *pt;

*pt = 606;

Because pt is not initialized and then it is dereferenced.

You also can't do this for the same reason (plus the types don't match):

*pt= &myVariable;

But you can do this:

pt= &myVariable;

After which you can freely use *pt.

When you write sometype *p = something;, it's equivalent to sometype *p; p = something;, not sometype *p; *p = something;. That means when you use a string literal like that, the compiler figures out where to put it and then puts its address there.

The statement

char *str = "Sometimes I feel like I'm going crazy.";

is equivalent to

char *str;

str = "Sometimes I feel like I'm going crazy.";

Good job on coming up with that example. It does a good job of showing the difference between declaring a pointer (like char *text;) and assigning to a pointer (like text = "Hello, World!";).

When you write:

char *text = "Hello!";

it is essentially the same as saying:

char *text;        /* Note the '*' before text */

text = "Hello!";   /* Note that there's no '*' on this line */

(Just so you know, the first line can also be written as char* text;.)

So why is there no * on the second line? Because text is of type char*, and "Hello!" is also of type char*. There is no disagreement here.

Also, the following three lines are identical, as far as the compiler is concerned:

char *text = "Hello!";

char* text = "Hello!";

char * text = "Hello!";

The placement of the space before or after the * makes no difference. The second line is arguably easier to read, as it drives the point home that text is a char*. (But be careful! This style can burn you if you declare more than one variable on a line!)

As for:

int *pt;

*pt = 606;   /* Unsafe! */

you might say that *pt is an int, and so is 606, but it's more accurate to say that pt (without a *) is a pointer to memory that should contain an int. Whereas *pt (with a *) refers to the int inside the memory that pt (without the *) is pointing to.

And since pt was never initialized, using *pt (either to assign to or to de-reference) is unsafe.

Now, the interesting part about the lines:

int *pt;

*pt = 606;   /* Unsafe! */

is that they'll compile (although possibly with a warning). That's because the compiler sees *pt as an int, and 606 as an int as well, so there's no disagreement. However, as written, the pointer pt doesn't point to any valid memory, so assigning to *pt will likely cause a crash, or corrupt data, or usher about the end of the world, etc.

It's important to realize that *pt is not a variable (even though it is often used like one). *pt just refers to the value in the memory whose address is contained in pt. Therefore, whether *pt is safe to use depends on whether pt contains a valid memory address. If pt isn't set to valid memory, then the use of *pt is unsafe.

So now you might be wondering: What's the point of declaring pt as an int* instead of just an int?

It depends on the case, but in many cases, there isn't any point.

When programming in C and C++, I use the advice: If you can get away with declaring a variable without making it a pointer, then you probably shouldn't declare it as a pointer.

Very often programmers use pointers when they don't need to. At the time, they aren't thinking of any other way. In my experience, when it's brought to their attention to not use a pointer, they will often say that it's impossible not to use a pointer. And when I prove them otherwise, they will usually backtrack and say that their code (which uses pointers) is more efficient than the code that doesn't use pointers.

(That's not true for all programmers, though. Some will recognize the appeal and simplicity of replacing a pointer with a non-pointer, and gladly change their code.)

I can't speak for all cases, of course, but C compilers these days are usually smart enough to compile both pointer code and non-pointer code to be practically identical in terms of efficiency. Not only that, but depending on the case, non-pointer code is often more efficient than code that uses pointers.