理解无符号数的行为

Question

My goal is have a sorted ascending list of unsigned int values, I use the sub_func to choose which one is greater.

The sub_func return is int because I want to compare which one is greater for all the numbers it works fine but, I have a problem when I define the max value of unsigned int which is ( 0xffffffff == -1 ). I want to understand more on unsigned numbers over here. How would I solve this problem?

I have the following code:

#define p_max (0xffffffff)
uint32 a = p_max;
uint32 b = 20;

int sub_func(uint32 a, uint32 b) 
{
    return (b - a);
}

The retrun is 21, where as I want it to be 20 - MAX, which will be negative and my return type is negative.

But, i see it always a positive number. which I dont want, how to workaround this?

Answer 1

(Assuming uint32 is a 32 bit unsigned integral type).

b - a is an expression with type uint32 since both operands are of that type. Due to the standards-defined wrap-around behaviour of uint32 , it will have the value of 21.

You are assigning that to an int type, hence the return value.

Answer 2

Don't mix int and uint unless it is really required as the max value is different because one bit will be used for sign.

Based on your latest comment, you can return 0 or 1 and then decide to add to tail/back or head/front.

uint32 sub_func(uint32 a, uint32 b)  
{
    if( a > b )
        return 0;
    else
        return 1;
}

You can also use bool data type if you want to return true or false. Adjust your function return code based on the comparison and return data type.

Answer 3

Frist, signed and unsigned of same type are stored in same a space of same size (for example signed char and unsigned char are stored on 1 byte). So, for signed , half of possible values are used to store positive values and the other part of possible values are used to store negative values. For unsigned , all possible values are for positive values only :

• signed char : -127 to 127
• unsigned char : 0 to 255

To calculate a negative, the most use solution is "two's complement". To store -1 :

• use of value of 1 : 0x01
• invert it : 0xFE
• add 1 : 0xFF

So, -1 is store in signed context as 255 in unsigned context.

It's for that every one say : don't mix signed and unsigned!

Or if you really need that, use a greater size to calculate signed and be carefull :

std::uint32_t a;
std::uint32_t b;

std::int64_t = static_cast<std::int64_t>(b) - static_cast<std::int64_t>(a)

Example with 8 and 16 bits size data : http://coliru.stacked-crooked.com/a/38076c588de3907d

Answer 4

What you are asking is impossible.

20 - 0xfffffff = -4294967275

which is not representable by an int, restricted to the range [-2147483648,2147483647] .

The difference of two unsigned requires 33 bits !

Answer 5

The fact you are storing the result in an int does not prevent the subtraction being done using unsigned arithmetic.

A subtraction of two uint32 always produces a result which is of type uint32 . If the mathematical result of the subtraction is negative, modulo arithmetic is used to produce a value between 0 and the maximum that the unsigned type can represent.

You have used that fact to get 0xFFFFFFFF from -1 . It works equally with results of subtraction.

20 - 0xfffffff gives a value of -4294967275 . That modulo 0x100000000 (the maximum a uint32 can represent, plus 1 ) is 21 ( 0x15 ). 21 converted to int is still 21 .

One way to produce a negative value is to avoid doing subtraction using unsigned variables, such as;

int sub_func(uint32 a, uint32 b) 
{
    return (a > b) ? 1 : ((a < b) ? -1 : 0));
}

Answer 6

As the limit for a signed 32-bit int is [-2147483648,2147483647], it cannot hold the result of subtraction as it is out of the limit. You can go for a 64-bit data type to hold the result of subtraction. I tested the below code on Visual studio.

#define p_max 0xffffffff

unsigned int a = p_max;
unsigned int b = 20;

signed long long sub_func() 
{
    return ((signed long long)b - (signed long long)a);
}

int main()
{
    signed long long x = sub_func();
}

Answer 7

In the following code, the question is why the nResult would be 21 .

#define p_max (0xffffffff)
uint32 a = p_max;
uint32 b = 20;

void main()
{
    int nResult = b - a;
}

You are trying to calculate:

0000 0000 0000 0000 0000 0000 0001 0100 - 1111 1111 1111 1111 1111 1111 1111 1111

which is actually computed as adding

1 (2's complement of 1111 1111 1111 1111 1111 1111 1111 1111 ) to

0000 0000 0000 0000 0000 0000 0001 0100 .

= 0000 0000 0000 0000 0000 0000 0001 0101

The result is 21 and there is no consideration of sign since it's produced by two uint32's operation. So it doesn't make any change even if you cast the result value to signed int, because it's already a positive value.

Answer 8

I just tested this with VC2013 and the compiler is treating the values as signed integers, hence getting 21! Here's the disembly:-

int sub_func(uint32 a, uint32 b)
{
00B813C0  push        ebp
00B813C1  mov         ebp, esp
00B813C3  sub         esp, 0C0h
00B813C9  push        ebx
00B813CA  push        esi
00B813CB  push        edi
00B813CC  lea         edi, [ebp - 0C0h]
00B813D2  mov         ecx, 30h
00B813D7  mov         eax, 0CCCCCCCCh
00B813DC  rep stos    dword ptr es : [edi]
return (b - a);
00B813DE  mov         eax, dword ptr[b]
00B813E1  sub         eax, dword ptr[a]
}
00B813E4  pop         edi
00B813E5  pop         esi
00B813E6  pop         ebx
00B813E7  mov         esp, ebp
00B813E9  pop         ebp
00B813EA  ret