May i know the difference between these initializations?

[shermaine80]

May i know the difference between

(1) char a[] = "string literal"
(2) char *p = "string literal"

char a[] is a array which will include the word "string literal"
whilw char *p is a pointer that points to a address that store the words "string literal"?

Is that correct? Please advise.

[Hurkyl]

I believe an array type is effectively the same thing as a pointer constant. (not a constant pointer!)

i.e. these two statements mean exactly the same thing

char a[] = something;
char *const a = something;

Functionally, going back to your original example, it simply means that p = a is a valid assignment, because you're allowed to change where p points, but a = p is not, because you're not allowed to change where a points.

[DrGreg]

I believe an array type is effectively the same thing as a pointer constant. (not a constant pointer!)

i.e. these two statements mean exactly the same thing

char a[] = "something";
char* const b = "something";

Functionally, going back to your original example, it simply means that p = a is a valid assignment, because you're allowed to change where p points, but a = p is not, because you're not allowed to change where a points.Actually there is a subtle difference between a and b.

sizeof(a) is 10 but sizeof(b) is 4 (typically, in a compiler where chars are one byte ("something" is 9 chars plus a NUL) and pointers are 4 bytes).

But in most other contexts, a and b behave identically.

[Sane]

And sizeof does make a difference!

For example, let's try to make a copy of each string dynamically.

char a[] = "1 String Literal";
char *a_p = malloc (sizeof (char) * sizeof (a));
memcpy (a_p, a, sizeof (char) * sizeof (a));
printf ("%s\n", a_p);
free (a_p);

Perfect! It works.

Now let's make a copy of the other string.

char *p = "2 String Literal";
char *p_p = malloc (sizeof (char) * sizeof (p));
memcpy (p_p, p, sizeof (char) * sizeof (p));
printf ("%s\n", p_p);
free (p_p);

Uh oh! It only outputs the first four characters!

Oh? But can't we just fix it by using the correct sizeof?

char a[] = "1 String Literal";
char *p = "2 String Literal";
char *p_p = malloc (sizeof (char) * sizeof (a));
memcpy (p_p, p, sizeof (char) * sizeof (a));
printf ("%s\n", p_p);
free (p_p);

Hurray! It works.

Now... in a real-world situation, you will not have an alternate initialization with the exact same number of characters to use a sizeof on. In that case, further methods can be used to acquire the correct size. Such as strlen under the string.h library, for example.

[DrGreg]

char *a_p = malloc (sizeof (char) * sizeof (a));
By the way, sizeof(char) is always 1.

(And even if it wasn't, the correct formulation would still be char* a_p = malloc(sizeof(a));)

[Sane]

Yes, you are right. However, I was trying to be as clear as possible.

Half of programming is knowing how to write efficiently and elegantly, the other half is showing clear and concise intentions with your code. This was an example of choosing to go with the latter, readability.