I heard that in c, if I do: char *s = "hello world". The "hello world" is actually stored in read-only memory.
I am not so clear about read-only memory. Can anybody explain? Is that like a flag to compiler that tells compiler that do not write into that section?
True read-only memory is implemented by the memory subsystem of the OS. The OS can mark certain pages as read-only.
In the binary, the compiler can tell the OS which parts of the executable should be placed in read-only vs read-write memory pages.
Executables contain two parts: a .data section, containing global variables, and a .text section, containing the actual machine code.
Strings are placed into the .data section. What C does when it sees "Hello world" is it puts the string "Hello world" into the executable itself, and replaces instance of "Hello world" in the program with the address where that string ends up being loaded.
Having said that, I'm not sure why it's read-only - theoretically a program should be able to modify its own memory..
That's not a feature of the c-language but a feature of the compiler/linker and the operation system working together.
When you compile such a code the following happens:
The compiler will put the string into a read-only data-section.
The linker collects all the data in such read-only sections and puts them into a single segment. This segment resides in the executable file and is flagged with a "read only"-attribute.
Now comes the operation system executable loader. It loads the executable (or maps it into memory to be more exact). Once this is done the loader walks the sections and sets access-permissions for each segment. For a read-only data segment it will most likely disable code-execute and write access. Code (e.g. your functions) gets execute rights but no write access. Ordinary data like static variables gets read and write access and so on...
That's now modern operation systems do it.
As said it's not a feature of the c-language. If you compile the same problem for DOS for example the program will run but no write protection would be possible because the DOS-loader does not know about read-only sections.
There's an example of how to do this in Linux here - http://books.google.cl/books?id=oRqqAVyXjwAC&pg=PA179&lpg=PA179&dq=linux+memory++readonly&source=bl&ots=LgBAMGXFkj&sig=dF0Ru0jDu5ktvm6ug29O8CwbQ2w&hl=en&ei=ALX4StrEHs6InQfZ09XtBQ&sa=X&oi=book%5Fresult&ct=result&resnum=15&ved=0CDYQ6AEwDg#v=onepage&q=&f=false (it's a link to a particular page of a Google book view)
You could try something like
s[4] = '0';
and see if it says "hello w0rld" when you call
puts(s);
If it causes an immediate Segmentation Fault or a Data Execution Prevention exception then it is probably read only. (If the system lets you get away with it, that doesn't make it a good idea.)
As other folks have mentioned, whether the contents of constant strings are stored in read-only memory is determined by the operating system, compiler, and chip architecture.
More precisely, the C standard specifies that the quoted strings are considered to have "const char[]" type (or words to that effect, I don't have the standard at hand).
Any code that attempts to modify the contents of such a string is invoking undefined behavior. That means that literally anything can happen at that point, and the provider of the compiler isn't even required to document what can happen.
In practice, this means that a C or C++ program that wants to be portable has to avoid modifying constant strings.
In general, the compiler will not allow you to modify the contents of of "const" variables, so you can consider "const" to mean "read only" in most cases. Unfortunately, there's a special exception for char * and const char *, largely for historical reasons. That means that code like this:
char *x = "Hello, World";
*x = 'h';
will compile without error or warning, even though it invokes undefined behavior.