Thread: Why does this code fail?

This fails:

Code:

char *s = "hello";
s[0] = 'H';

but this doesn't:

Code:

char s[] = "hello";
s[0] = 'H';

or this:

Code:

char *s = "hello";
printf("%c\n", s[0]);

Besides being a constant pointer, I've always thought char [] was equivalent to char *.

Originally Posted by Yasir_Malik

Besides being a constant pointer, I've always thought char [] was equivalent to char *.

And you have now discovered that it's not.

I thought I wrote a reply earlier...

Can you please describe what you mean by "fails", as I don't see anything that is OBVIOUSLY wrong with your code. But "fails" and "works" are fairly broad terms - "works" could mean that it doesn't crash, but if it comes up with $-1927489231.32 as my "balance" after I've paid this months electrics bill, it may not be quite "working correctly" - so it failed on the next level: operating CORECTLY!

Also, it would help if you could give a little more code around these code-snippets, because it may be something else that is making it go wrong...

--
Mats

Originally Posted by matsp

Can you please describe what you mean by "fails"

I assume it crashes. You can't modify a string literal on most platforms.

Originally Posted by brewbuck

I assume it crashes. You can't modify a string literal on most platforms.

Ah, yes, it crashes on my machine too - for that very reason, the string appears to be in "code" (or is it called "text") memory, so it can't be written to.

--
Mats

But why does assigning to an index in char str[] work? Is there something special about char *str that puts the string into the text memory, not into data memory?

Code:

char s[] = "something";

creates an array of char that is long enough to hold "something", and initialized to that value. Since the variable "s" is in data-memory, and it's containing "something", it can be written to.

Code:

char *s = "something"

creates a pointer s, that points to the constant string "something". Since "something" is a constant, it's not expected to be written to.

Similarly if you do a function-call:

Code:

void blah(char *s)
{
   ...
}

...
    blah("something");
...

blah can't change the input string [and some compilers may catch that by saying "loosing const attribute" or some such].

--
Mats

I see now. It goes back to how char s[] is a constant pointer while char *p is just a pointer. Since it can point to anything, it would pointless to have the string "something" floating around; otherwise, there would be a memory leak if I did char *p = "asdf" multiple times in a function.

I was thinking about doing this many times:

Code:

void func(void)
{
 char *s = "hello";
}

If the compiler allocated memory for s in the data segment. Eventually there would be "hello"s everywhere.
In addition, s can point to anywhere, so it could point to another char * later on in the code. "hello" would be lost and so would that memory; you can't call delete or free on that. Instead, allocate "hello" once in the text segment.

Originally Posted by Yasir_Malik

I see now. It goes back to how char s[] is a constant pointer while char *p is just a pointer.

char s[] is not a "constant pointer." It is an array. The name of the array acts like a constant pointer in an R-value context. That's the relationship, not more, not less.

The reason the char s[] version is writable is precisely BECAUSE it is an array.