gcc 4 signed vs unsigned char

[juanitofoo]

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors. How can I use the signed or unsigned char?

I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

Thanks in advance.

[guorke]

ju********@gmai l.com wrote:

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors. How can I use the signed or unsigned char?

I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

Thanks in advance.

in gcc 3.4. it's ok!

[Michael Mair]

ju********@gmai l.com wrote:

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors. How can I use the signed or unsigned char?

I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

The type char is - for historical reasons - distinct from signed char
and unsigned char and may be effectively (signedness, size, range)
either the one or the other.
So, only
char *p = "Hola";
is always correct.
Cheers
Michael
--
E-Mail: Mine is an /at/ gmx /dot/ de address.

[Keith Thompson]

ju********@gmai l.com writes:

I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors. How can I use the signed or unsigned char?

I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

Why would you want to use either signed char or int8_t for a character
string? The correct declaration is

char *p = "Hola";

"Plain" char is a distinct type from both signed char and unsigned
char, though it has the same representation as one of them.

However, the warning is misleading. The initialization is illegal (a
constraint violation), but the pointer targets don't actually differ
in signedness. I've just submitted a bug report; see
<http://gcc.gnu.org/bugzilla/show_bug.cgi?id =23087>.

--
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.

[Me]

ju********@gmai l.com wrote:

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors.
"Hola" is a const char[5] which can be implicitly converted to const
char * and also unfortunately to just char *. What makes you think it
can also be implicitly converted to signed char *?

It's best to just think of unsigned char as the native byte type,
signed char as the corresponding signed integer, and plain char as a
separate native character type that just happens to be required to be
represented by either an unsigned char or signed char. It's unfortunate
it is this way but it's very, very unlikey to change.
How can I use the signed or unsigned char?
static signed char hola[] = "Hola";
signed char *p = hola;

Maybe you're confused why this works but your example doesn't. It's
because this is just syntax sugar for:

static signed char hola[5] = { 'H', 'o', 'l', 'a', '\0' };
signed char *p = hola;

(you can also get rid of the static and/or add a const qualifier. I
don't know how your actual code looks like from this small snippet)
I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

who said int8_t and uint8_t must be typedeffed to a character type in
the first place? Consider it a good thing you get this warning (it
would be better if it was an error instead).

[Eric Sosman]

Me wrote:

ju********@gmai l.com wrote:

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors.

"Hola" is a const char[5] which can be implicitly converted to const
char * and also unfortunately to just char *.

Almost, but not quite. "Hola" is a char[5] that decays
to char* in most circumstances. Neither the array nor the
pointer is const-qualified, even though it is forbidden to
try to modify the array.

--
Er*********@sun .com

[Old Wolf]

ju********@gmai l.com wrote:

Hello,
I've just switched to gcc 4 and I came across a bunch of warnings that
I can't fix. Example:

#include <stdio.h>

int main()
{
signed char *p = "Hola";

return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

Only if I remove the signed from the declaration it compiles without
errors. How can I use the signed or unsigned char?
You should write code that works just as well whether plain char
is signed or not.
I'm using gcc 4.0.1. The reason for asking this is because in one
program I'm always using int8_t and u_int8_t values, and both of them
are signed or unsigned, no simply 'char' variables.

You could avoid the warning with:
signed char *p = (signed char *)"Hola";

However I can't think of a reason why you would prefer this
to:
char const *p = "Hola";

Can you post some code that demonstrates why you need to
point to non-const, signed chars?

[Keith Thompson]

Eric Sosman <er*********@su n.com> writes:

Me wrote:

[...]

"Hola" is a const char[5] which can be implicitly converted to const
char * and also unfortunately to just char *.

Almost, but not quite. "Hola" is a char[5] that decays
to char* in most circumstances. Neither the array nor the
pointer is const-qualified, even though it is forbidden to
try to modify the array.

"Forbidden" in the sense that attempting to do so invokes undefined
behavior. For some implementations , this is indistinguishab le from it
being allowed.

--
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.

[Old Wolf]

Keith Thompson wrote:

ju********@gmai l.com writes:

int main()
{
signed char *p = "Hola";
return 0;
}

If I compile that file, I get:
kk.c: In function 'main':
kk.c:5: warning: pointer targets in initialization differ in signedness

However, the warning is misleading. The initialization is illegal (a
constraint violation), but the pointer targets don't actually differ
in signedness. I've just submitted a bug report...

I, for one, am happy with the warning issued: "definitely signed"
is different to "maybe signed".

Plus the OP didn't indicate whether his implementation has plain
char signed or not, and if plain char were unsigned, then the
warning is definitely correct. GCC has a switch for that, and I
also think it defaults to unsigned on appropriate platforms
(eg. ARM).

[Keith Thompson]

"Old Wolf" <ol*****@inspir e.net.nz> writes:

Keith Thompson wrote:

ju********@gmai l.com writes:

>
> int main()
> {
> signed char *p = "Hola";
> return 0;
> }
>
> If I compile that file, I get:
> kk.c: In function 'main':
> kk.c:5: warning: pointer targets in initialization differ in signedness
>
However, the warning is misleading. The initialization is illegal (a
constraint violation), but the pointer targets don't actually differ
in signedness. I've just submitted a bug report...

I, for one, am happy with the warning issued: "definitely signed"
is different to "maybe signed".

But "signed though it's not required to be" and "signed because it's
required to be" don't "differ in signedness". The message should say
that they differ in type.

If I saw that message and didn't know that plain char is signed, I
would naturally assume that the compiler is complaining because plain
char is unsigned. If I found that plain char really is unsigned, I'd
submit a bug report against the compiler. (In fact, I did!)
Plus the OP didn't indicate whether his implementation has plain
char signed or not, and if plain char were unsigned, then the
warning is definitely correct. GCC has a switch for that, and I
also think it defaults to unsigned on appropriate platforms
(eg. ARM).

The warning wouldn't be as incorrect if plain char were unsigned, but
it would still be misleading. The initialization is illegal because
the pointer types are incompatible (and the pointer types are
incompatible because the target types are distinct types), *not*
just because the target types differ in signedness.

gcc 4.0.0 produces the warning "pointer targets in initialization
differ in signedness" for both of the following lines:

signed char *ps = "signed?";
unsigned char *pu = "unsigned?" ;

--
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.