Why is 'char -> int' promotion, but 'char -> short' is conversion (but not promotion)?

Question

I've read cppreference.com's implicit conversion:

Integral promotion:
prvalues of small integral types (such as char) may be converted to prvalues of larger integral types (such as int).

[...]

Note that all other conversions are not promotions; for example, overload resolution chooses char -> int (promotion) over char -> short (conversion).

The conversion from char to int is 'promotion'; it's clear (from one byte to 4 bytes).
The conversion from char -> short is 'not promotion'; why?
I've been thinking that char is one byte, and short (short int) is two bytes. Why isn't it considered a promotion? It seems to contradict the first line. Doesn't it mean 'convert from small type to bigger type' is promotion?)

---

After looking for some answers:

Can we consider "a promotion is a special case of a conversion"? Can we say "all promotions are conversions, but not all conversions are promotions"?
Or should we consider them as two different and separate concepts?

Answer 1

Historical motivation: C

The idea of integral promotions dates all the way back to pre-standard C. When providing arguments to variadic functions (...) or to functions without a prototype, promotions are applied. I.e. calling:

// function declaration with no prototype
void mystery();
// ...
char c = 'c';
mystery(c); // this promotes c to int

// in another .c file, someone could define
void mystery(int x) { /* ... */ }

Promotions are basically a "minimal" upgrade to the type, whereas conversions can be anything. You could even argue that the design is a consequence of building on the B programming language, which didn't even have multiple integer types like C does.

Relevant wording in the C++ Standard

Only the following are considered integer promotions:

A prvalue that is not a converted bit-field and has an integer type other than bool, char8_t, char16_t, char32_t, or wchar_t whose integer conversion rank is less than the rank of int can be converted to a prvalue of type int if int can represent all the values of the source type; otherwise, the source prvalue can be converted to a prvalue of type unsigned int.

- [conv.prom] p2

The difference between promotions and conversions is explained here:

The conversions allowed as integral promotions are excluded from the set of integral conversions.

- [conv.integral] p4

As you can see, there is some overlap between the two concepts, but any conversion which would also be a promotion is not considered a conversion.

Whether a standard conversion is a promotion or a conversion has an impact on overload resolution:

Standard conversion sequences are ordered by their ranks: an Exact Match is a better conversion than a Promotion, which is a better conversion than a Conversion. [...]

- [over.ics.rank] p4

Impact on overload resolution

As you've pointed out, char -> short is a conversion, and char -> int is a promotion. This has the following impact:

// A conversion sequence from char -> int is empty
// because char -> int is a promotion, and so it doesn't contribute
// to the conversion sequence.
void f(int);
// A conversion sequence from char -> short has length 1
// because char -> short is not a promotion.
void f(short);

int main() {
    // Not an ambiguous call; calls f(int), because the conversion sequence
    // for this call is shorter.
    // Note that in C, a character literal has type 'int', not 'char', so
    // it is more symmetrical to favor 'int' whenever possible.
    f('x');
}

If C++ was designed from scratch nowadays, promotions and conversions would likely be defined a lot differently, however, the status quo is what we have, and it's unlikely to change. Changing this behavior and wording after all these years is basically impossible because of how much code depends on it.

As with so many design decisions in C++, the answer is: historical reasons.

Answer 2

Both char to int and char to short are conversions. Note the text’s use of “all other conversions” after discussing promotions: Promotions are a type of conversion.

A conversion is an operation that takes a value in one form and produces the same value (as nearly as possible) in another form:

• Taking a char value and producing an int with the same value is a conversion.
• Taking an int value and producing a string containing a decimal numeral representing the same value is a conversion.
• Taking a weight in pounds and producing the same weight in kilograms is a conversion.

In many places in expressions, C++ automatically converts narrow integer types to wider integer types. This is done largely for historical purposes, and also because it could be awkward to do arithmetic purely in narrow types—char arithmetic would overflow too easily, and requiring the programmer to explicitly insert casts to int would make code cumbersome.

These special conversions are called “promotions.” The natural English meaning of the word, advancing to a higher position, fits these types of conversions: They all convert from a narrower type to a wider type (or to one at least as wide). Aside from that, the word is adopted to particularly designate these special conversions. An important feature of the integral promotions is they never change the value. (Ideally, no conversion would change a value, but this does happen due to constraints. One example is that converting a float value of 3¼ to int must produce an integer, so 3 is produced instead of 3¼. Another is that converting an int value of −3 to unsigned forces wrapping, so a value that is very different nominally is produced, although it does have a special relationship with the input value and can be considered the same value in modulo arithmetic.)

Answer 3

The C++ standard specifies a set of rules for integral promotions, and these rules are not solely based on the size of the types. The decision to promote a char to an int rather than a short is based on the historical design of the language and the desire for consistent behavior across different platforms.

According to the C++ standard, integral promotions are defined to convert small integral types to a particular implementation-defined type, which is usually int. Since int is chosen as the target type for integral promotion, converting a char to a short doesn't qualify as a promotion, even though short is larger than char. It falls under the category of conversions instead.

The specific rules can vary between different implementations and architectures, but this is the general reasoning behind the behavior you observed. It's a part of the language's design, guided by historical considerations and practical aspects of compiler implementation, rather than a strictly logical progression based on type size.

Answer 4

The promotions are a subset of conversions performed implicitly in certain circumstances, even if the target type is not given. Here are two of them:

• Many built-in arithmetic operators "promote" their arguments to int if they are of lesser rank. The following program prints 256, because both chars are promoted to int before they are added, and the resulting expression has type int; by contrast, the second printf prints 0, because ++ does not promote its argument so that the 8 bit value overflows (which is defined for unsigned types).

#include <cstdio>
int main()
{
    unsigned char c1 = 255, c2 = 1;
    std::printf("%d\n", c1 + c2);
    std::printf("%d\n", ++c1);
}

• Talking about printf: Integral arguments of lesser rank than int which do not have a corresponding parameter in the function declaration (like the second arguments in the printf calls above) are promoted to int. It is impossible to pass genuine chars to printf. (Note that in the second printf above, the expression ++c1 has type unsigned char, with the value 0, which is promoted to int when the argument is passed, but after the evaluation of the expression.)

Other widening conversions which are not promotions, like in unsigned short c = 'a';, are performed because the target of an assignment, the type of a formal parameter or an explicit conversion demand it.