转换有符号和无符号数字

Question

I had a function that was producing invalid input when dividing a signed number by an unsigned number. What this means is that the negative number was being interpreted as unsigned and so was making a calculation invalid. For example, here are the possibilities when dividing between two potentially signed numbers:

printf ("%d %d %d %d %d %d %d %d %d",
        (signed)10 / (signed)8,
        (unsigned)10 / (signed)8,
        (unsigned)10 / (unsigned)8,
        
        (signed)-10 / (signed)8,
        (unsigned)-10 / (signed)8,       // bad result
        (unsigned)-10 / (unsigned)8,     // bad result
        
        (signed)-10 / (signed)-8,
        (unsigned)-10 / (signed)-8,     // ??
        (unsigned)-10 / (unsigned)-8    // ??
);

---

$ run
// 1 1 1 -1 536870910 536870910 1 0 0

What are the rules for when a signed number is divided by an unsigned number? Are both numbers cast to the same type before the calculation? Or is the result cast? It seems in the function I had a signed negative number that was being divided by an unsigned positive number, which I thought would "just work", but it seems them instead of the types being implicitly converted so that my number would be, for example, "-1", the result came out to be a very large positive number. What are the rules when mixed-sign numbers are operated on?

Answer 1

For each of arguments, three things happen in this order:

1. The conversions specified by the casts are performed.
2. The two operands of / are converted to a common type.
3. The argument is passed to printf to be converted to text by %d .

Let's discuss these in order.

1. Casts and Conversions

A conversion is a change of value from one type to another. Where possible, a conversion does not change the value. Otherwise, we desire conversions to change the value as little as possible (converting 3.125 from float to int produces 3, not 87) or in some information-preserving way (conversions from a 32-bit int to a 32-bit unsigned int “wrap” modulo 2 ³² ).

Some conversions occur automatically. For example, in int x = 3.125f; , the float value 3.125 is converted to the int value 3.

To explicitly request a conversion, we use a cast. A cast operator has the form ( type ) expression . A cast is specifically this operator. Automatic conversions are not casts.

When a signed integer with value x is converted to an n -bit unsigned integer, the result is, the result is what you get by taking x and adding or subtracting 2 ⁿ until you get a value that is representable in the unsigned integer type. For example, when −10 is converted to a 32-bit unsigned int , 2 ³² (4,294,967,296) is added once, producing −10 + 4,294,967,296 = 4,294,967,286. When −8 is converted, the result is −8 + 4,294,967,296 = 4,294,967,288.

These both had to add 2 ³² just once to bring the value in range. To see an example where multiple additions or subtractions are necessary, consider converting 1001 to eight-bit unsigned char . The three subtractions of 256 are necessary to bring the result into the range 0 to 255, so the result is 1001 − 3•256 = 1001 − 768 = 233.

2. The Usual Arithmetic Conversions

For many C binary operators, particularly the arithmetic operators, the two operands are converted to a common type perform the operation is performed. (This is largely due to how computer hardware works; it is easy to multiply two unsigned numbers or two signed numbers but somewhat awkward to multiply a signed number by an unsigned number.) The rules for this are called the usual arithmetic conversions .

For example, the specification for the / operator in C 2018 6.5.5 3 says “The usual arithmetic conversions are performed on the operands.” The usual arithmetic conversions are specified in C 2018 6.3.1.8. The rules are expressed with a technical concept of rank and other details but may be summarized for standard real types: If either operand is earlier in the list below than int , it is converted to int . (This part is called the integer promotions .) After that, if the two operand types are different, the operand with the earlier type is converted to the later type:

• _Bool , signed char , char , unsigned char , short , unsigned short , int , unsigned int , long , unsigned long , long long , unsigned long long , float , double , long double .

Here is how this affects your examples, demonstrated with a 32-bit int (aka signed ) and a 32-bit unsigned (aka unsigned int ):

• (signed)10 / (signed)8 . Both operands are int . 10/8 is computed, and the result is 1.
• (unsigned)10 / (signed)8 . (signed)8 is converted to unsigned , which does not change the value. 10/8 is computed, and the result is 1.
• (unsigned)10 / (unsigned)8 . Both operands are unsigned int . 10/8 is computed, and the result is 1.
• (signed)-10 / (signed)8 . Both operands are int . −10/8 is computed, and the result is −1.
• (unsigned)-10 / (signed)8 . (unsigned)-10 is 4,294,967,286. (signed)8 is converted to unsigned int , which does not change the value. 4,294,967,286/8 is computed, and the result is 536,870,910.
• (unsigned)-10 / (unsigned)8 . (unsigned)-10 is 4,294,967,286. Both perands are unsigned int . 4,294,967,286/8 is computed, and the result is 536,870,910.
• (signed)-10 / (signed)-8 . Both operands are int . −10/−8 is computed, and the result is 1.
• (unsigned)-10 / (signed)-8 . (unsigned)-10 is 4,294,967,286. (signed)−8 is converted to unsigned int , which changes the value to 4,294,967,288. 4,294,967,286/4,294,967,288 is computed, and the result is 0.
• (unsigned)-10 / (unsigned)-8 . (unsigned)-10 is 4,294,967,286. (unsigned)−8 is 4,294,967,288. 4,294,967,286/4,294,967,288 is computed, and the result is 0.

3. printf Conversion Specifiers

The result of the division operator, / , has the same type as the operands after the usual arithmetic conversions. So some of your arguments have type int , and some have type unsigned int .

When %d is used in the printf format, the corresponding argument is supposed to be an int . This is specified in C 2018 7.21.6.1 8 (which is about fprintf , but the fprintf clause refers to it). Paragraph 9 says “… If any argument is not the correct type for the corresponding conversion specification, the behavior is undefined.”

So, formally, the behavior of your program is not defined by the C standard. However, C implementations often let this substitution of an unsigned int argument for an int argument slide, and the program “works” due to a combination of historical reasons and how software and hardware work. (This substitution is explicitly allowed when calling a function declared without a prototype, in C 2018 6.5.2.2 6. One might argue that if you did not include <stdio.h> and declared printf yourself with int printf(); , it would be allowed by that rule.)

So, in spite of having behavior not defined by the C standard, it is unsurprising your program prints the results described above. However, it would be better to change %d to %u for the cases where the argument is unsigned int .

Answer 2

With (unsigned)-10 , what you get at compilation is 4294967295 (uint32_t max value, due to the underflow), minus 10 , then divided by 8, which is indeed 536870910.

As for your different divisions, the result is standard defined (credit @Barmar)