C string assignment gives segmentation fault

Question

I am new to C and I want perform this task: declare and initialize a string and then reassign each string element to a new value.

Writing the code in this way:

char *str = "geeksforgeeks\0";

for (int i = 0; str[i] != '\0'; ++i) {
    str[i] = 'a';
}

throws a segmentation fault.

But if I write the code in this manner:

char string[] = "geeksforgeeks\0";
char *str = string;

for (int i = 0; str[i] != '\0'; ++i) {
    str[i] = 'a';
}

the program behaves correctly.

Also this code:

char str[] = "geeksforgeeks\0";

for (int i = 0; str[i] != '\0'; ++i) {
    str[i] = 'a';
}

behaves correctly.

What is the difference between the two? Should't be equivalent?

Answer 1

char *str = "geeksforgeeks\0";

This string is allocated in readonly* memory and you can't modify it. Also the null terminator there is redundant.

Same is not the case with the array you defined, that is why it works. In the case with array the string literal is copied to memory where array resides - and you can modify contents of that array. So using this

char *str = string;

you point to the first element of the array - which as mentioned, is modifiable (as well as all elements of the array).

_{*It can be they are stored not in read only memory, depends on platform. But anyway you are not allowed to modify them.}

Answer 2

If you have:

char *str = "geeksforgeeks\0";

the string is (usually) stored in read-only memory and you get a segmentation fault when you try to modify it. (The \0 is really not needed; you have two null bytes at the end of the string.)

The simplest fix is to use an array instead of a constant string (which is basically what you do in the second working case):

char str[] = "geeksforgeeks";

Note that you should really use this for the string since the string is not modifiable:

const char *str = "geeksforgeeks";

Answer 3

The reason is simple.

In first example, you have a pointer to an static string. that's why you get a segmentation fault.

char *str = "Test";

This is practically a constant string. But in 2nd example, it is a variable that you change.

// You have a variable here
char str_array[] = "Test";
// Now you have a pointer to str_array
char *str = str_array;

Answer 4

You’ve hit on a bit of ugly legacy baggage. When you write the literal "geeksforgeeks\0", the compiler turns that into a pointer to an array of characters. If you later use the string "geeksforgeeks\0" again, it’s allowed to point both references to the same array. This only works if you can’t modify the array; otherwise, fputs(stdout, "geeksforgeeks\0"); would be printing aeeksforgeeks. (Fortran can top this: on at least one compiler, you could pass the constant 1 by name to a function, set it equal to -1, and all your loops would then run backwards.) On the other hand, the C standard doesn’t say that modifying string literals won’t work, and there’s some old code that did. It’s undefined behavior.

When you allocate an array to hold the string, you’re creating a unique copy, and that can be modified without causing errors elsewhere.

So why aren’t string literals const char * instead of char *? Early versions of C didn’t have the const keyword, and the standards committee didn’t want to break that much old code. However, you can and should declare pointers to string literals as const char* s = "geeksforgeeks\0"; so the compiler will stop you from shooting yourself in the foot.