string constant

hello everybody,

consider the following statement,
char *s = "someString";

Does the above statement cause "someString" to be alloted a constant
memory space. What I mean is can't we manipulate "someString" using
statements like

s[0] = 'a';

re: string constant

chandanlinster <chandanlinster@gmail.comwrote:
It might; implementations are allowed to make this choice for
themselves.
No. Not portably, at least, although some implementations offer the
ability to modify string literals as an extension.

--
C. Benson Manica | I *should* know what I'm talking about - if I
cbmanica(at)gmail.com | don't, I need to know. Flames welcome.

re: string constant

"chandanlinster" <chandanlinster@gmail.comwrites:No, attempting to modify a string literal invokes undefined behavior.

(For historical reasons, string literals are not treated as "const";
attempting to modify one invokes UB because the standard says so
explicitly.)

Some implementations may allow you to do this. Don't.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

re: string constant

Keith Thompson wrote:But it's still worth declaring them as const.

--
Ian Collins.

re: string constant

Ian Collins <ian-news@hotmail.comwrites:Yes.

More pedantically, if you have an array whose initializer is a string
literal, it's a good idea to declare the array as const.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

re: string constant

Keith Thompson wrote:Wouldn't that depend on the purpose of the array?

/* const ??? */ char devname[] = "/dev/pty?";
char *p = strchr(devname, '?');
char *q;
FILE *stream;
for (q = "abc"; *q != '\0'; ++q) {
*p = *q;
stream = fopen(devname, "r+");
if (stream != NULL)
return stream;
}
return NULL;

In my experience, an explicit array is initialized with a
string literal only when one *does* want to modify it; if one
does not, one simply uses the literal. Do you write

const char message[] = "Hello, world!";
puts (message);

or simply

puts ("Hello, world!");

?

--
Eric Sosman
esosman@acm-dot-org.invalid

re: string constant

Eric Sosman <esosman@acm-dot-org.invalidwrites:[...][snip]

Yes, sorry, I goofed.

If you have a *pointer* whose initializer is a string literal, you
should declare it as const:

const char *p = "hello";

If you have an *array*, declare it as const or not depending on how
you want to use it; the initializer is irrelevant:

char arr[] = "hello";

Here, the string literal is (logically) *copied* to the array. In the
first case, the pointer actually points to the string literal itself.
More precisely, the string literal causes an anonymous array of static
storage duration, just large enough to hold the sequence of
characters, to be created. The pointer points to this array. Any
attempt to modify the array invokes UB.

--
Keith Thompson (The_Other_Keith) kst-u@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.