When does conversion between unsigned and signed character pointer becomes unsafe in C?

Question

If I do this in both clang and Visual Studio:

  unsigned char *a = 0;
  char * b = 0;

  char x = '3';

  a = & x;

  b = (unsigned char*) a;

I get the warning that I am trying to convert between signed and unsigned character pointer but the code sure works. Though compiler is saying it for a reason. Can you point out a situation where this can turn into a problem?

`int i; unsigned u = 0; for ( i = 10; i >= u; --i ) { puts("Do this forever."); }` — Crowman, Jun 05 '14 at 11:59

Adriano Repetti · Answer 1 · 2014-06-21T22:35:07.687

3

To make it very simple because char represents:

A single character (char, it doesn't matter if signed or not). When you assign a character like 'A' what you're doing is to write A ASCII code (65) in that memory location.
A string (when used as array or pointer to a char buffer).
An eight bit number (with or without sign).

Then when you convert a signed byte like -1 to unsigned byte you'll loose information (at least sign but probably number too), that's why you get a warning:

signed char a = -1;
unsigned char b = (unsigned char)a;
if ((int)b == -1)
    ; // No! Now b is 255!

Value may not be 255 but 1 if your system doesn't represent negative numbers with 2's complement, in that example it doesn't really matter (and I never worked with any system like that but they exist) because the concept is a signed/unsigned conversion may discard information. It doesn't matter if this happens because of an explicit cast or a cast through pointers: bits will represent something else (and result will change according to implementation, environment and actual value).

Note that for C standard char, signed char and unsigned char are formally distinct types. You won't care (and VS will default char to signed or unsigned according to a compiler option but this isn't portable) and you may need casting.

edited Jun 21 '14 at 22:35

answered Jun 05 '14 at 11:56

Adriano Repetti

65,416
20
137
208

So, if the only thing that I assign my unsigned and signed characters are strings, the difference does not matter then? – user1343318 Jun 05 '14 at 11:58
Yes but don't forget that char, signed char and unsigned char are formally distinct types (it matters if you use them as inputs of library functions). To the end it doesn't matter but you may need casting. – Adriano Repetti Jun 05 '14 at 12:01
`(int)b == -1` yields true. – this Jun 05 '14 at 12:02
1

@self. It yields `false` as we all expect. If `b` is `unsigned char` then **original negative value has been lost**. Can you explain how `255 == -1` in any compiler you may use? – Adriano Repetti Jun 05 '14 at 12:06
@AdrianoRepetti Looks like I found a compiler bug :9 – this Jun 05 '14 at 12:10
@self. wow, if you're compiling in release it may be an optimization (unexpected because cast has side effects) – Adriano Repetti Jun 05 '14 at 12:18
@AdrianoRepetti Confirmed; optimization bug. – this Jun 05 '14 at 12:19
@AdrianoRepetti It is worse than that. Removing every cast in the code, doesn't remove the bug. – this Jun 05 '14 at 12:26
@self. I'm not (so) surprised when there are no casts but with casts it's pretty unexpected! Which compiler are you using? – Adriano Repetti Jun 05 '14 at 12:57

score 0 · Answer 2 · answered Jun 05 '14 at 12:22

Your code is correct (any type can be aliased by unsigned char). Also, on 2's complement systems, this alias is the same as the result of a value conversion.

The reverse operation; aliasing unsigned char by char is only a problem on esoteric systems that have trap representations for plain char.

I don't know of any such systems ever existing, although the C standard provides for their existence. Unfortunately a cast is required because of this possibility, which is more annoying than useful IMHO.

The aliasing of unsigned char by char is the same as the value conversion on every modern system that I know of (technically implementation-defined, but everyone implements it that the value conversion retains the same representation).

NB. definition of terms, taking for example unsigned char x = 250;:

alias char y = *(char *)&x;
conversion char y = x;

score 0 · Answer 3 · answered Jun 21 '14 at 22:40

The char type can either be signed or unsigned depending on the platform. The code that you write with casting a char type to either unsigned or signed char might work fine within one platform, but not if the data is transferred across operating systems, ETC. See this URL:

http://www.trilithium.com/johan/2005/01/char-types/

score -2 · Answer 4 · answered Jun 05 '14 at 11:56

-2

Because you can lose some values - look at this:

unsigned char *a = 0;
char b = -3;
a = &b;
printf("%d", *a);

Result: 253

Let me explain this. Just look at ranges:

unsigned char: from 0 to 255
signed char: from -128 to 127

Edited: sorry for mistake, too hot today ;)

answered Jun 05 '14 at 11:56

aso

1,331
4
14
29

Even with the fixed code the result is correct: 253 – this Jun 05 '14 at 11:58

When does conversion between unsigned and signed character pointer becomes unsafe in C?

4 Answers4

Linked