Returning a pointer to a constant string

[=?iso-8859-1?q?Santiago_Urue=F1a?=]

Hi,

I tried to return a pointer to a constant string, but the compiler
gives the following warning if a cast is not used:

warning: assignment from incompatible pointer type

This is the code:
const char msg[] = "Test message";

const char *message(void) {
return msg;
}

int main(void){
const char * str;

str = (const char *)message;
str = (char *)message;
str = message; /* GCC warning! */

str = (const char *)msg;
str = (char *)msg;
str = msg;

return 0;
}

Oddly, GCC only gives the warning if no cast is used, but it doesn't
complain if the cast discards the const qualifier. Is this behavior
OK? I'm using GCC 4.1.2. Thanks!

Best regards,

Santi

[Keith Thompson]

Richard Heathfield <rj*@see.sig.in validwrites:

Eric Sosman said:

>Richard wrote On 09/19/07 12:54,:

>>[...] in what
cases are &msg[0] and msg not the same in real live systems where they
are 32 or 64 bit pointers?

In all cases.

Not so. &msg[0] and msg are identical when their value is used in an
expression.

When their value is used, yes, but the question was whether they're
the same in general. (The sizes of pointers are irrelevant.)

When they're the operand of a sizeof operator, their values are not
used, but they differ. Likewise for the operand of unary "&"
(but as has been pointed out, '&&msg[0]' is a constraint violation).

--
Keith Thompson (The_Other_Keit h) ks***@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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[pete]

Richard wrote:

>
Eric Sosman <Er*********@su n.comwrites:

Richard wrote On 09/19/07 12:54,:

Keith Thompson <ks***@mib.orgw rites:
[...]
Since msg is declared as an array, the expression '&msg' is the
address *of the array*, whereas the expression 'msg' (in most
contexts) yields the address of the arrsy's first element,
the same as '&msg[0]'.

I'm a bit sleepy at the moment and understand the above,
but in what
cases are &msg[0] and msg not the same in real live
systems where they
are 32 or 64 bit pointers?

In all cases.

In what cases are the VALUES not the same.

Given: const char msg[] = "Test message";
the answer to your question is that
(&msg[0] == msg) equals one, on all C implementations .

I am not talking the types.
hence I mentioned the pointers or addresses.

He was talking types.

The point he was making is that
though ((char *)&msg == (char *)msg) equals one,
(&msg == msg) is undefined.

--
pete

[Richard Heathfield]

Keith Thompson said:

Richard Heathfield <rj*@see.sig.in validwrites:

>Eric Sosman said:

>>Richard wrote On 09/19/07 12:54,:
[...] in what
cases are &msg[0] and msg not the same in real live systems where they
are 32 or 64 bit pointers?

In all cases.

Not so. &msg[0] and msg are identical when their value is used in an
expression.

When their value is used, yes, but the question was whether they're
the same in general.

Um, no, the question was: "in what cases are &msg[0] and msg not the same
in real live systems where they are 32 or 64 bit pointers?"

Clearly the pointer-size thing is of no interest to comp.lang.c, since the
cases where &msg[0] and msg are the same or not the same is nothing to do
with pointer size as far as we're concerned. So it resolves to: "in what
cases are &msg[0] and msg not the same?" Nothing in there about "in
general". Eric's answer to this (which he acknowledges is based on a
misreading of what is probably a typo!) was "in all cases", which is
clearly not correct, because there is a case where &msg[0] and msg are the
same.

(The sizes of pointers are irrelevant.)

Agreed.

When they're the operand of a sizeof operator, their values are not
used, but they differ. Likewise for the operand of unary "&"
(but as has been pointed out, '&&msg[0]' is a constraint violation).

Yes, there are indeed cases where they differ, but "in some cases" != "in
all cases".

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Keith Thompson]

Richard Heathfield <rj*@see.sig.in validwrites:

Keith Thompson said:

>Richard Heathfield <rj*@see.sig.in validwrites:

>>Eric Sosman said:
Richard wrote On 09/19/07 12:54,:
[...] in what
cases are &msg[0] and msg not the same in real live systems where they
are 32 or 64 bit pointers?

In all cases.

Not so. &msg[0] and msg are identical when their value is used in an
expression.

When their value is used, yes, but the question was whether they're
the same in general.

Um, no, the question was: "in what cases are &msg[0] and msg not the same
in real live systems where they are 32 or 64 bit pointers?"

Sorry, I misunderstood your correction to be more general that it
obviously was. (I should spend more time reading and thinking when
something you post looks wrong; it happens, but it's not the way to
bet.)

--
Keith Thompson (The_Other_Keit h) ks***@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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"