Legitimate usage of char*

Question

I am having a little bit of trouble understanding the use of pointers. Specifically, I am confused about the following line of code:

char* s = "my String";

I have two questions:

1. Is this code even legitimate? From watching some of the Harvard CS 50 videos, I would think that it is.

2. If the answer to (1) is yes, then I am quite confused. I thought the meaning of the statement: "char* s" is that you want to create a new variable called s that is of type char*. This means that s is a pointer to some char variable (and at this point, we don't even know what this char variable is). If this is the case, then the right hand side of the above line of code should be an address in memory, and not a string.

I would be more comfortable with something like:

char s[10] = "my string"; //10 because including extra space for null 0  
char* AddressOfs = &s;

EDIT/UPDATE: Thanks for all the great answers. David K's answer has made things much clearer (I like the step-by-step structure), but I am still a bit confused in some respects.

3. In step 1 of David K's answer, he said that

   It will reserve 10 bytes of memory somewhere.

But it has to reserve more than just 10 bytes, right? We need 10 bytes for the contents of the string plus 4 bytes for the contents of the address in memory.

4. Do you agree with the following: So if we stick with the "variables-as-containers" analogy, the line

   char* s = "my string";
   

reserves 14 bytes of storage (10 for the contents of the string and 4 for the address of the contents of the string), but there is only one "container". This container is named s and holds the 4 bytes. The 10 bytes that hold the contents of the string are "container-less", i.e. these 10 bytes are allocated somewhere in memory, but there is no label that we can associate with these 10 bytes. (I'm not saying we have no way of accessing these 10 bytes. I'm just saying that there is no formal variable label that is being applied to these 10 bytes.)

Answer 1

If you have this line of code in your source file,

char* s = "my String";

here's what your program will do:

1. It will reserve 10 bytes of memory somewhere.
2. It will put the characters of "my String" (including terminating null) in those ten bytes of memory.
3. It will declare s as a char*.
4. It will set the value of the pointer, s, to the address of the first byte of those 10 bytes of memory, where the character 'm' resides.

So it really is not very much different from this:

const char s_buffer[10] = "my String";
char* s = &s_buffer[0];

One difference that you might notice is that in the first case, there is no symbol s_buffer that you can make use of separately from s. In the first example, if the very next line is s = "another string" then (at least in principle) you lose the ability to read the particular 10 bytes that s intially pointed to.

Answer 2

char* s = "my String"; declares a string constant and a pointer to it. It's no less legitimate than using a bare string in, say, a printf call. Note, however, that because you have a pointer to your string you might be tempted to try to modify it -- that is undefined behaviour.

Answer 3

In your case

 char* s = "my String"

is legal and valid, because a representation like "my String" is called a string literal and the representation essentially gives the address of the first element in the string, which is again a pointer to a char. So, we can store that in another pointer to a char.

The usability, is mostly same with char s[10] = "my string";, except the fact that in former case, s pointing to a string literal, you cannot (even attempt to) modify it. Trying so will invoke undefined behavior.