initialisation of a char pointer using char *s = "something"

[Brice Rebsamen]

Reading the code from showkey.c (from package kbd) I found this type
of code:

char *m;
m = "RAW";

See below for the complete code. How can this work? I would have used
strdup, or allocation of the memory for m (static or dynamic) then
strncpy.

Thanks
Brice
static void
get_mode(void) {
char *m;

if (ioctl(fd, KDGKBMODE, &oldkbmode)) {
perror("KDGKBMODE");
exit(1);
}
switch(oldkbmode) {
case K_RAW:
m = "RAW"; break;
case K_XLATE:
m = "XLATE"; break;
case K_MEDIUMRAW:
m = "MEDIUMRAW"; break;
case K_UNICODE:
m = "UNICODE"; break;
default:
m = _("?UNKNOWN?"); break;
}
printf(_("kb mode was %s\n"), m);
if (oldkbmode != K_XLATE) {
printf(_("[ if you are trying this under X, it might not work\n"
"since the X server is also reading /dev/console ]\n"));
}
printf("\n");
}

[Ian Collins]

Brice Rebsamen wrote:

Reading the code from showkey.c (from package kbd) I found this type
of code:

char *m;
m = "RAW";

The character pointer m (which should probably be a const char*) points
to the string literal "RAW".

See below for the complete code. How can this work? I would have used
strdup, or allocation of the memory for m (static or dynamic) then
strncpy.

Remember m it a pointer.

--
Ian Collins.

[WANG Cong]

On Tue, 11 Mar 2008 21:10:20 -0700，Brice Rebsamen wrote：

Reading the code from showkey.c (from package kbd) I found this type of
code:

char *m;
m = "RAW";

See below for the complete code. How can this work? I would have used
strdup, or allocation of the memory for m (static or dynamic) then
strncpy.

In C, you should treat the string "RAW" as a pointer to char.

>
Thanks
Brice
static void
get_mode(void) {
char *m;

if (ioctl(fd, KDGKBMODE, &oldkbmode)) {
perror("KDGKBMODE");
exit(1);
}
switch(oldkbmode) {
case K_RAW:
m = "RAW"; break;
case K_XLATE:
m = "XLATE"; break;
case K_MEDIUMRAW:
m = "MEDIUMRAW"; break;
case K_UNICODE:
m = "UNICODE"; break;
default:
m = _("?UNKNOWN?"); break;

Hmm, you must have a function named "_", and it takes a (const) char*
parameter, right?

[Chris Thomasson]

"WANG Cong" <xi************@gmail.comwrote in message
news:fr**********@news.cn99.com...

On Tue, 11 Mar 2008 21:10:20 -0700，Brice Rebsamen wrote：

>Reading the code from showkey.c (from package kbd) I found this type of
code:

char *m;
m = "RAW";

See below for the complete code. How can this work? I would have used
strdup, or allocation of the memory for m (static or dynamic) then
strncpy.

In C, you should treat the string "RAW" as a pointer to char.

[...]

What about treating it as a pointer to a const char?

[...]

[Peter Nilsson]

Brice Rebsamen <[e-mail]:

Reading the code from showkey.c (from package kbd) I
found this type of code:

char *m;
m = "RAW";

See below for the complete code. How can this work?

What makes you think it can't?

I suspect your confusion stems from m not being const
qualified, and string literals having type char[] in C.

I would have used strdup, or allocation of the memory
for m (static or dynamic) then strncpy.

<snip>

Why bother?

Take a look at the following and see if the penny drops...

#include <stdio.h>

void foo(const char *m)
{
puts(m);
}

void bar(void)
{
const char *m = "Hello"; /* what's the diff? */
puts(m);
}

int main(void)
{
foo("Hello");
bar();
return 0;
}

Given the points I mentioned earlier, realise that
I could leave out the const-s, though it wouldn't
be good form.

--
Peter

[J. J. Farrell]

Brice Rebsamen wrote:

Reading the code from showkey.c (from package kbd) I found this type
of code:

char *m;
m = "RAW";

See below for the complete code. How can this work? I would have used
strdup, or allocation of the memory for m (static or dynamic) then
strncpy.

...

This is not a meaningful question. It obviously does work, and my
immediate response to your question was "how can it not work". You need
to explain why you find this surprising, then we'll be able to sort out
your confusion.

[Brice Rebsamen]

On Mar 12, 12:55 pm, Peter Nilsson <[e-mail]:

Brice Rebsamen <[e-mail]:

Reading the code from showkey.c (from package kbd) I
found this type of code:

char *m;
m = "RAW";

See below for the complete code. How can this work?

What makes you think it can't?

I suspect your confusion stems from m not being const
qualified, and string literals having type char[] in C.

I would have used strdup, or allocation of the memory
for m (static or dynamic) then strncpy.

<snip>

Why bother?

Take a look at the following and see if the penny drops...

#include <stdio.h>

void foo(const char *m)
{
puts(m);
}

void bar(void)
{
const char *m = "Hello"; /* what's the diff? */
puts(m);
}

int main(void)
{
foo("Hello");
bar();
return 0;
}

Given the points I mentioned earlier, realise that
I could leave out the const-s, though it wouldn't
be good form.

--
Peter

Still I'm confused. Take a look at the following:

const char *getm1(void) { char m[] = "Hello"; return m; }
const char *getm2(void) { return "Hello"; }

getm1 raises a warning about returning the address of a local variable
and returns a corrupted string. This I have known for a long time. My
explanation is that the memory is released when the function returns,
therefore whatever happens to m is undefined (possibly overwritten).
I don't understand why it's not the case with getm2().

[Brice Rebsamen]

On Mar 12, 2:05 pm, Brice Rebsamen <[e-mail]:

On Mar 12, 12:55 pm, Peter Nilsson <[e-mail]:

Brice Rebsamen <[e-mail]:

Reading the code from showkey.c (from package kbd) I
found this type of code:

char *m;
m = "RAW";

See below for the complete code. How can this work?

What makes you think it can't?

I suspect your confusion stems from m not being const
qualified, and string literals having type char[] in C.

I would have used strdup, or allocation of the memory
for m (static or dynamic) then strncpy.

<snip>

Why bother?

Take a look at the following and see if the penny drops...

#include <stdio.h>

void foo(const char *m)
{
puts(m);
}

void bar(void)
{
const char *m = "Hello"; /* what's the diff? */
puts(m);
}

int main(void)
{
foo("Hello");
bar();
return 0;
}

Given the points I mentioned earlier, realise that
I could leave out the const-s, though it wouldn't
be good form.

--
Peter

Still I'm confused. Take a look at the following:

const char *getm1(void) { char m[] = "Hello"; return m; }
const char *getm2(void) { return "Hello"; }

getm1 raises a warning about returning the address of a local variable
and returns a corrupted string. This I have known for a long time. My
explanation is that the memory is released when the function returns,
therefore whatever happens to m is undefined (possibly overwritten).
I don't understand why it's not the case with getm2().

Messages come really fast here! I found a clear answer in c-faq 1.32.
Thanks all.