为什么我能够像这样将新字符串重新分配给 C 中的 char 指针（ch *string = “hello”; string = “assign”;）

Question

I would like to know why the following code is legal

char *string = "hello";
string = "changed";
string = "changed again";

This does not cause any problem with the compiler.

But I was under the impression that char arrays initialized as a pointer (char *string as opposed to char string[]) are read-only and cannot be overwritten?

Answer 1

The string data could be laid out like this in memory:

Addr Contents
---- --------
1000 h e l l o \0
1006 c h a n g e d \0
1014 c h a n g e d   a g a i n \0

When you initialize the variable string , it contains the address 1000 . The first reassignment changes it to 1006 , the second changes it to 1014 . The string data itself is not being overwritten.

Answer 2

Think about this (explanations to follow). There are big differences between

char *string1 = "hello";
char *string2 = "world";
string1 = string2;

and

char string3[] = "hello";
char string4[] = "world";
strcpy(string3, string4);

and

char *string5 = "hello";
char *string6 = "world";
strcpy(string5, string6);            /* WRONG */

and

char string7[] = "hello";
char string8[] = "world";
string7 = string8;                   /* VERY WRONG */

Make sure you understand how the 1/2 and 3/4 cases are different but both work. Make sure you understand why both the 5/6 and 7/8 cases are wrong and won't work (but for different reasons).

---

Explanations:

After

char string3[] = "hello";
char string4[] = "world";

you have two arrays initialized in memory that look like this:

         +---+---+---+---+---+---+
string3: | h | e | l | l | o |\0 |
         +---+---+---+---+---+---+

         +---+---+---+---+---+---+
string4: | w | o | r | l | d |\0 |
         +---+---+---+---+---+---+

And after calling

strcpy(string3, string4);

you end up with

         +---+---+---+---+---+---+
string3: | w | o | r | l | d |\0 |
         +---+---+---+---+---+---+

         +---+---+---+---+---+---+
string4: | w | o | r | l | d |\0 |
         +---+---+---+---+---+---+

strcpy copied characters from array4 to array3 . (Note, too, that the original string3 and string4 happened to have the same length. It also would have worked if string4 had been shorter, but if string4 had been longer, there would have been an array overflow when copying it to string3 .)

Now to the pointer case. After

char *string1 = "hello";
char *string2 = "world";

you have two anonymous arrays, typically in read-only memory, pointed to by two pointer variables that look like this:

         +-----------+      +---+---+---+---+---+---+
string1: |     *----------->| h | e | l | l | o |\0 |
         +-----------+      +---+---+---+---+---+---+

         +-----------+      +---+---+---+---+---+---+
string2: |     *----------->| w | o | r | l | d |\0 |
         +-----------+      +---+---+---+---+---+---+

And then after

string1 = string2;

the pointers are rearranged to look like this:

         +-----------+      +---+---+---+---+---+---+
string1: |     *     |      | h | e | l | l | o |\0 |
         +-----|-----+      +---+---+---+---+---+---+
               |
               +--------------+
                              |
                              V
         +-----------+      +---+---+---+---+---+---+
string2: |     *----------->| w | o | r | l | d |\0 |
         +-----------+      +---+---+---+---+---+---+

But I was under the impression that char arrays initialized as a pointer (char *string as opposed to char string[]) are read-only and cannot be overwritten?

Right. And that's what goes wrong in the

char *string5 = "hello";
char *string6 = "world";
strcpy(string5, string6);            /* WRONG */

case. strcpy tries to write new characters to string5 , which fails if the pointed-to string has been stored in read-only memory. For the same reason you can't do something like

string5[0] = 'H';                    /* WRONG */

Answer 3

"But I was under the impression that char arrays initialized as a pointer (char *string as opposed to char string[]) are read-only and cannot be overwritten?"

That's "kinda sorta" true, depending on how you look at it. When the compiler hits an assignment to a literal, it sets aside a bit of memory for the literal and points your char* to it. Depending on compiler and architecture you might not be able to change that memory. In all cases you should never try to change that memory (after all you don't know where it's been). In that way the actually memory where the string literal (the actual character values) is stored may very well be read-only.

In the case you have shown you aren't changing the memory that contains the characters. You are changing the address that string points to. Assuming you are defining string in a function, the value will be allocated on the stack. It will be sizeof(void *) and that memory can be changed … it is changed when you change what string points to. You are changing the address where "changed" is stored to the address where "changed again" is stored.