29 Implicit conversions — promotion and the usual arithmetic conversions

The words this chapter leans on throughout — arithmetic type, integer type, what integer promotion acts on — are as defined in chapter 26. If they blur, open those families again.

29.1 Rule 1 — integer promotion

Integer promotion: when a value of an integer type smaller than int — char, short, bool, a bit-field — takes part in an arithmetic operation, it is widened to int before the calculation (to int if int can hold all its values, otherwise to unsigned int).

#include <stdint.h>
#include <stdio.h>

int main(void)
{
    /* integer promotion: char and short are widened to int before the arithmetic */
    signed char a = 100;
    signed char b = 100;
    printf("100 + 100 (as chars) = %d\n", a + b);   /* 200 — a value a char cannot hold */

    /* the usual arithmetic conversions: the unsigned side wins —
       read -1 through unsigned eyes and it becomes a huge positive number */
    int neg = -1;
    printf("(unsigned)(-1)   = %u\n", (unsigned)neg);
    printf("so -1 < 1u is false\n");

    /* integer division vs real division — the cast states the intent */
    int total = 7, count = 2;
    printf("7 / 2        = %d\n", total / count);
    printf("(double)7/2  = %.1f\n", (double)total / count);

    /* the default promotions of variadic arguments: float to double, char/short to int */
    float f = 1.5f;
    printf("float 1.5f via %%f = %f  (promoted to double)\n", f);
    return 0;
}

100 + 100 (as chars) = 200
(unsigned)(-1)   = 4294967295
so -1 < 1u is false
7 / 2        = 3
(double)7/2  = 3.5
float 1.5f via %f = 1.500000  (promoted to double)

The first line is the check — two signed char values of 100 were added and the result is 200. The reason a value that does not fit in a char did not overflow is that the addition happened not in char’s world but in int’s.

The reason lies in the machine (chapter 11). A CPU’s arithmetic circuits and registers are built to handle integers around the word size, so having separate arithmetic just for small types would be inefficient. C took that reality into the language as a rule — small types are units of storage, not units of calculation.

29.2 Rule 2 — the usual arithmetic conversions

If the two operands still differ in type after promotion, the usual arithmetic conversions settle on one common type. The order to remember in practice:

• If one side is floating, go to the floating side (long double > double > float).
• If both are integers — go to the wider one. At equal width, the unsigned side wins.

Spelled out in the standard’s own order, the integer rules are four steps.

Figure 29.1 — Follow the four in order. Most accidents happen at step 3.

That last line is the source of the trap. The second part of the demonstration is it in the flesh — read -1 through unsigned eyes and it becomes an enormous positive number over four billion (exactly chapter 7′s modular world). So a comparison like -1 < 1u comes out false, against intuition. That is why mixing signed values into array indices or size calculations (the result of sizeof is the unsigned size_t!) causes silent accidents.

Fortunately the compiler guards this trap well — the warnings switched on in chapter 17 point at sign-mixed comparisons (one example in this book was caught by that warning and rewritten). Reduced to a rule: do not mix signed and unsigned in one comparison. Use the size_t family consistently for sizes and indices, or state the intent with an explicit cast.

29.3 Rule 3 — default promotions for variadic arguments

The third conversion happens in functions whose argument count is not fixed — variadic functions such as printf. Arguments passed into a position where the prototype states no type undergo default argument promotions: float becomes double, and small integer types become int.

The demonstration’s last line is the check — a float value printed with %f comes out fine. The format %f in fact expects a double, and the float argument arrived as a double after promotion (which is why printf has no float-specific format at all). The “contract between format and materials” learned in chapter 22 has this promotion rule as a hidden clause — the full contract, and how to write variadic functions yourself, is faced head on in chapter 58.

We have the families of conversions. From the next chapter come the tools of flow — beginning with the booleans and comparisons that turn judgement into a value.