6

Consider the following C++ code:

#include <cstdio>

using namespace std;

int main()
{
    int ia = -5;
    unsigned int uia = ia;
    char ca = -5;
    unsigned char uca = ca;

    printf("%d\n", (ia == uia));
    printf("%d\n", (ca == uca));

    return 0;
}

The output is

1
0

I don't understand what's the difference between int and char while casting from signed to unsigned?

Could you please enlighten me?

Deanie
  • 2,316
  • 2
  • 19
  • 35
imsrch
  • 1,152
  • 2
  • 11
  • 24
  • 4
    `char` is wierd. It's distinct from `signed char`. – Pubby Apr 14 '13 at 03:47
  • The last answer for this [question on SO](http://stackoverflow.com/questions/4337217/difference-between-signed-unsigned-char) has some info on the 3 kinds of char; char, signed char, and unsigned char are all distinct. – Dave Newman Apr 14 '13 at 03:53

3 Answers3

7

They both behave the same when converting from signed to unsigned. What behaves differently is the == comparison. It behaves as expected for the int/unsigned, but when you compare two smaller types, they both get promoted to int first. So what happens is that the unsigned 8-bit representation of -5 and -5 both get promoted to int and then get compared. These are obviously different and fail the comparison.

Mark B
  • 95,107
  • 10
  • 109
  • 188
  • It would be great if you also mention the promoted values. – Nawaz Apr 14 '13 at 04:36
  • The binary present of value -5 of `char` is `11111011`.And the binary present of `unsigned char` is the same(`11111011`).But when a char was convert to int, compiler should keep the value of char and int is the same. Because `char` is -5, so `int` should also be -5.And then a `unsigned char` was convert to int, the value of it show also be keep unchanged.The value of `unsigned char` is 251,so the `int` is 251.That's why `char` -5 is not equals to `unsigned char` -5. – Expressway Retrograding Apr 14 '13 at 04:44
1

ok, the actual reason for this inconsistent behavior is the underlying promoting of char and unsigned. I'd like to explain this more specificcally.

first, when compaire with a int and an unsigned int variable, their types do not matter because no matter what types they are, their have the same binary-representation in memory, that is what == operator cares.

Whereas when == applies to a char and an unsigned char varialbes, they will firstly expand to the corresponding 32-bit integer type, and how they got expaneded is the key of the inconsistency. Since ca is a char, it will be extended with the sign-bit （via MOVSX） while uca will be extended only with padding 0 (via MOVZX). Thus, they now have inconstent binary-representation.

The assembly code tells this truth.

    int b1 = ia == uia;
000613E5  mov         eax,dword ptr [ia]  
000613E8  xor         ecx,ecx  
000613EA  cmp         eax,dword ptr [uia]  
000613ED  sete        cl  
000613F0  mov         dword ptr [b1],ecx  
    int b2 = ca == uca;
000613F3  movsx       eax,byte ptr [ca]  
000613F7  movzx       ecx,byte ptr [uca]  
000613FB  xor         edx,edx  
000613FD  cmp         eax,ecx  
000613FF  sete        dl  
00061402  mov         dword ptr [b2],edx
Kingsley Chen
  • 276
  • 4
  • 12
-3

a signed type can be negative aswell as postive. while unsigned are higher in value but can not go negative.

so respectively an unsigned int's max value is 4,294,967,296. and its minimum is 0.

while a signed int's range is -2,147,483,648 to 2,147,483,648.

i hope this helps you understand the difference between signed and unsigned types.

this feature can come in handy when you want to avoid a value being negative. such as a refrence into an array. or if you need only positive large values and no negatives. to save you needing to go up to a long.

Zanven
  • 144
  • 6