在ANSI C中使用指针替换字符

Question

I am using ubuntu 12.04lts with gcc(Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3. I can replace a character in a 1st program, but why can't i get output in 2nd program, even it is compiled successfully?. I get segmentation fault. Can anyone explain the reason?

  #include<stdio.h>
  int main(void)
  {
  char word[] = "Bhilip";
  char *cp = word ;
  puts(word);
  cp[1] = 'T';  // allowed??
  puts(word);
  return 0;
  }



  #include<stdio.h>
  int main(void)
  {
    char * p1 = "Bhilip";
    p1[0] = 'T';    //allowed?
    printf("\nThilip");
    printf(" %s \n\n", "Thilip");
    return 0 ;
  }

Answer 1

char * p1 = "Bhilip";

declares a pointer to a string literal. This may be held in read only memory so cannot be modified.

p1[0] = 'T';

tries to modify the first character in the string literal. This results in undefined behaviour, including possibly a segfault.

If you want a writeable string, you can declare a stack buffer and initialise it with a string literal

char p1[] = "Bhilip";
p1[0] = 'T'; // now allowed

Answer 2

As per ISO C11 6.4.5 String literals /6 (though this behaviour has been around for quite a while in earlier iterations of the standard):

It is unspecified whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undefined.

That means you are not permitted to modify the contents of string literals if you want the behaviour to be well defined. It may work on certain implementations but it's in no way guaranteed. In some implementations, string literals are placed into memory that is marked read-only so that attempting to modify it causes a fault to be raised. In others (such as embedded systems), it may be placed in actual read-only memory (ROM) so that, even if it doesn't fault, the memory remains unchanged.

One likely reason behind this is that it gives the compiler the ability to fold string literals together for efficiency. For example, if your code has the two strings defined and undefined , they may exist in memory as:

        +---+---+---+---+---+---+---+---+---+----+
0x1234: | u | n | d | e | f | i | n | e | d | \0 |
        +---+---+---+---+---+---+---+---+---+----+

with the address of undefined as 0x1234 and the address of defined as 0x1236 .

The reason that this works:

char word[] = "Bhilip";

is because it creates an array of characters that is legally modifiable, effectively:

• creating the modifiable array; then
• copying the individual characters into it.

In other words, it's functionally equivalent to:

char word[7];             // modifiable
strcpy (word, "Bhilip");  // initialise