0

This code I am looking at has a lot of places where I see things like this happening:

char *functionName(char *passedVariable)
{
    unsigned char *newVariable = (char* ) passedVariable;

Why is this being done? I always try to be consistent in the use of signed/unsigned, because I know that switching between the two can cause problems, but this developer doesn't seem to care.

petFoo
  • 407
  • 1
  • 6
  • 16

5 Answers5

1

Changing the pointer type is not really an issue, this address will still be valid. However interpreting the pointed data as signed/unsigned makes a difference if and only if... the signed data is negative. So in your example if your char's are always positive, then it's ok, otherwise it is not.

Example of signed/unsigned casts:

char c = 42;
char d = -42;
unsigned char cu = c;
unsigned char du = d;

printf("c  %d\n", c);
printf("cu %d\n", cu);
printf("d  %d\n", d);
printf("du %d\n", du);

Output:

c  42
cu 42
d  -42
du 214
wap26
  • 2,180
  • 1
  • 17
  • 32
  • This is cool. Thank you for showing me the result of each of these. I know that changing the signedness of variables in C is can be tricky, and having something that illustrates it in this way is very helpful! – petFoo Jun 20 '12 at 17:59
0

They might for example be UTF-8 strings, which consist of unsigned bytes and might be desirable to manually process as such, and yet they're safe to pass to printf which on many platforms expects a signed char so you have to cast somewhere to avoid a warning.

jjrv
  • 4,211
  • 2
  • 40
  • 54
  • can you please elaborate? I don't fully understand what you are saying. – petFoo Jun 20 '12 at 18:21
  • If you manually check UTF-8 string length for example, there's some bitwise operations dealing with unsigned chars. On the other hand to print the string to a unicode-enabled console, you can just use printf. Printf expects a plain "char *" which often translates to "signed char *". So either you have to cast the string to gets its length or to print it, both operations often cannot be done with the same type of pointer, even though the cast doesn't actually alter anything but some bitwise operation semantics. – jjrv Jun 20 '12 at 18:25
0

In the case of strings, which your example looks like, it probably doesn't matter. ASCII values only go from 0-127, which means they'll fit in either a signed or an unsigned char without trouble. In addition, the signedness of an undecorated char is implementation defined (hence the existence of the signed keyword). If char were an unsigned type, your example wouldn't have any sign conversions at all.

In general, the type of casting in your example is used to shut up "pointer sign" warnings when working with third party code that uses different coding styles or makes different assumptions about the signedness of char. It's not always possible to stay consistent in such a case, but casting to change the sign of string pointers is unlikely to cause any problems.

Carl Norum
  • 219,201
  • 40
  • 422
  • 469
  • "it probably doesn't matter" -- A common reason to use `unsigned char *` is when using the ctype.h functions that require unsigned char values (or EOF); then it does matter. – Jim Balter Jun 20 '12 at 16:24
  • @HotLicks It's true. I only noticed this line of code because my compiler gave a warning about it. It and an entire other page of warnings. – petFoo Jun 20 '12 at 18:46
0

For a pointer it doesn't matter, so long as signed and unsigned chars are the same size in memory this is just the address. And unsigned char * makes the most sense for an arbitrary memory address - which is why most purely memory functions take it as an arguemnt

Martin Beckett
  • 94,801
  • 28
  • 188
  • 263
0

The signedness of char is not specified by the C language because a character is not by nature a signed value and, when C was standardized, some implementations treated them as signed and some did not. So, it is always safe to convert char to either signed char or unsigned char. The former isn't common but the latter is in order to use the char as an array index or an argument of the ctype.h is... and to... functions. But without seeing any of the actual code that uses the unsigned char* pointer, it's impossible to be sure why it is being used.

Jim Balter
  • 16,163
  • 3
  • 43
  • 66
  • In this particular example, it looks like he's not using the variable that gets declared for anything important. He uses it in an if statement, but the if statement doesn't do anything. It just has a note commented out saying that it needs better error handling. But this is not the only place he does this in the project. – petFoo Jun 20 '12 at 17:57