segmentation fault in c program

Question

just for testing i had created the following code:

#include<stdio.h>

int main(){
    char *p = "Hello world";
    *(p+1) = 'l';
    printf("%s", p);
    return 0;
}

But when i ran this over my "gcc" compiler under ubuntu 10.04 I got:

Segmentation fault

So can anyone explain this why this happened.

#include<stdio.h>
#include<stdlib.h>

int main(){
    char *p = malloc(sizeof(char)*100);
    p = "Hello world";
    *(p+1) = 'l';
    printf("%s", p);
    free(p);
    return 0;
}

this also cause a segmentation fault Thanks in Advance

possible duplicate of [Why does simple C code receive segmentation fault?](http://stackoverflow.com/questions/164194/why-does-simple-c-code-receive-segmentation-fault) — Joe, Dec 11 '10 at 12:38
... and about 2 dozen other SO questions over the last few years. — Joe, Dec 11 '10 at 12:39

score 5 · Accepted Answer · edited Nov 22 '17 at 10:48

5

char *p = "Hello world"; *(p+1) = 'l';

Modiying the content of a string literal (i.e "Hello World" in your code) is Undefined Behavior.

ISO C99 (Section 6.4.5/6)

It is unspeciﬁed whether these arrays are distinct provided their elements have the appropriate values. If the program attempts to modify such an array, the behavior is undeﬁned.

Try using array of characters.

char p[] = "Hello World";
p[1] = 'l';

EDIT

Your modified code

#include<stdio.h>
#include<stdlib.h>
int main()
{
   char *p = malloc(sizeof(char)*100);
   p = "Hello world"; // p now points to the string literal, access to the dynamically allocated memory is lost.
   *(p+1) = 'l'; // UB as said before edits
   printf("%s", p);
   free(p); //disaster
   return 0;
}

invokes Undefined Behaviour as well because you are trying to deallocate the section of memory (using free) which has not been allocated using malloc

edited Nov 22 '17 at 10:48

Matthieu

2,736
4
57
87

answered Dec 11 '10 at 12:36

Prasoon Saurav

91,295
49
239
345

hey please check the modified question – codeomnitrix Dec 11 '10 at 12:41
... and because the read-only memory is still being modified, as after `p = "Hello world"` p doesn't point to the `malloc`ed memory any more. – Vlad Dec 11 '10 at 12:45
ok then does that mean the previously allocated memory (via malloc) is lost and right now what i m using is a new memory part of memory allocated by compiler for string literal "Hello world". Am i right? – codeomnitrix Dec 11 '10 at 12:46

paxdiablo · Answer 2 · 2010-12-11T13:05:51.647

Because char *p = "Hello world" has almost certainly given you a pointer to read-only memory and that means that trying to change it with *(p+1) = 'l' is a definite no-no (even if the memory isn't read-only, the behaviour is still undefined).

The relevant part of C99 referring to string literals is in 6.4.5 para 6:

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.

The reason why you still get a segmentation fault with something like:

char *p = malloc (100);  // sizeof(char) is ALWAYS 1
p = "Hello";             // better would be: strcpy (p, "Hello")
*p = 'a';

is because, even though you're allocating memory which you're allowed to modify, the second statement changes the pointer to point to a string literal (giving you a mmory leak as you lose access to the allocated memory), which you are not allowed to modify.

You need to differentiate changes to the pointer from changes to what the pointer points at.

That's because you're changing the pointer to point to another string literal, _not_ trying to change the string literal itself. — paxdiablo, Dec 11 '10 at 12:40
ok, but what if memory is allocated through malloc. as i had done in the new code section of my problem. — codeomnitrix, Dec 11 '10 at 12:44

score 1 · Answer 3 · answered Dec 11 '10 at 12:37

"Hello world" is a string literal. It is represented by a chunk of bytes in a region of memory which may not be modified. char *p points at that chunk of bytes. *(p+1) = 'l' says to overwrite the next byte after the pointed-at one with an 'l'. The next byte after the pointed-at one is part of the chunk which may not be modified. Attempting to overwrite something is attempting to modify it. Attempting to modify something which is not allowed to be modified is very bad.

In order to have a copy of the text in memory which may be modified, put it into an array, e.g. char p[] = "Hello world";. (Notice that declaring the array this way makes it exactly big enough to hold the string, and therefore you may not lengthen it, since there is no more room.)

segmentation fault in c program

3 Answers3