What does it mean for a char to be signed?

Question

Given that signed and unsigned ints use the same registers, etc., and just interpret bit patterns differently, and C chars are basically just 8-bit ints, what's the difference between signed and unsigned chars in C? I understand that the signedness of char is implementation defined, and I simply can't understand how it could ever make a difference, at least when char is used to hold strings instead of to do math.

Answer 1

It won't make a difference for strings. But in C you can use a char to do math, when it will make a difference.

In fact, when working in constrained memory environments, like embedded 8 bit applications a char will often be used to do math, and then it makes a big difference. This is because there is no byte type by default in C.

Answer 2

In terms of the values they represent:

unsigned char:

• spans the value range 0..255 (00000000..11111111)

• values overflow around low edge as:

  0 - 1 = 255 (00000000 - 00000001 = 11111111)

• values overflow around high edge as:

  255 + 1 = 0 (11111111 + 00000001 = 00000000)

• bitwise right shift operator (>>) does a logical shift:

  10000000 >> 1 = 01000000 (128 / 2 = 64)

signed char:

• spans the value range -128..127 (10000000..01111111)

• values overflow around low edge as:

  -128 - 1 = 127 (10000000 - 00000001 = 01111111)

• values overflow around high edge as:

  127 + 1 = -128 (01111111 + 00000001 = 10000000)

• bitwise right shift operator (>>) does an arithmetic shift:

  10000000 >> 1 = 11000000 (-128 / 2 = -64)

I included the binary representations to show that the value wrapping behaviour is pure, consistent binary arithmetic and has nothing to do with a char being signed/unsigned (expect for right shifts).

Update

Some implementation-specific behaviour mentioned in the comments:

• char != signed char. The type "char" without "signed" or "unsinged" is implementation-defined which means that it can act like a signed or unsigned type.
• Signed integer overflow leads to undefined behavior where a program can do anything, including dumping core or overrunning a buffer.