shaanxxx wrote:
void foo(char * str)
{
str[0] = str[0];
}
int main()
{
const char str[] = "Hello";
foo(str); // i get warning here
foo("shaan"); // i dont get warning here.
}
You get a warning on the first call to foo because
str (in main) is a `const' string, but the argument of
foo is not `const'. "Adding" a restriction is harmless,
but "subtracting" a restriction generates a diagnostic.
You do not get a warning on the second call because
the literal "shaan" generates a string that is not `const'.
That is an accident of history, having to do with the way
C developed and was used before the `const' keyword came
into the language. The peculiar outcome is that a string
constant is not `const', but you must act as if it were.
Both calls to foo invoke undefined behavior by trying
to modify the string:
- In the first case the string is actually `const' and
it is undefined behavior to attempt to modify a
`const' object.
- In the second case the string is not `const', but it
is undefined behavior to attempt to modify a string
constant.
And yes: Replacing a character with itself is in fact an
attempt to "modify" the string, even though the modification
(if it succeeded) would give the string the same content as
it had before.
should i interpret above programme as, String returns pointer to char
(which is non-constant).
Above statement is correct ?
Sorry; I do not understand this.
--
Eric Sosman
es*****@acm-dot-org.invalid
