隐式类型提升规则

这篇文章旨在用作有关C语言中隐式整数提升的FAQ，尤其是由通常的算术转换和/或整数提升引起的隐式提升。

示例1）
为什么给出一个奇怪的大整数而不是255？

unsigned char x = 0;
unsigned char y = 1;
printf("%u\n", x - y); 

示例2）
为什么给出“ -1大于0”？

unsigned int a = 1;
signed int b = -2;
if(a + b > 0)
  puts("-1 is larger than 0");

示例3）
为什么在上面的示例中更改类型以short解决问题？

unsigned short a = 1;
signed short b = -2;
if(a + b > 0)
  puts("-1 is larger than 0"); // will not print

（这些示例适用于16位短的32位或64位计算机。）

C被设计为隐式和无声地更改表达式中使用的操作数的整数类型。在几种情况下，语言会迫使编译器将操作数更改为更大的类型，或者更改其符号。

其基本原理是为了防止算术期间意外溢出，而且还允许具有不同符号的操作数在同一表达式中共存。

不幸的是，隐式类型提升的规则弊大于利，以至于它们可能是C语言中最大的缺陷之一。这些规则通常对于普通C程序员来说甚至是未知的，因此会引起各种非常细微的错误。

通常情况下，您会看到程序员说“只需强制转换为x即可使用它”的情况-但他们不知道为什么。或者，这些bug表现为看似简单而直接的代码中罕见的间歇性现象。隐式提升在进行位操作的代码中特别麻烦，因为在给定有符号操作数的情况下，C中大多数位运算符的行为都定义不明确。

整数类型和转换等级

在C中的整数类型是char，short，int，long，long long和enum。
_Bool/bool在类型促销中也被视为整数类型。

所有整数都有指定的转换等级。C11 6.3.1.1，强调最重要的部分：

每个整数类型均具有如下定义的整数转换等级：
—即使两个具有符号的整数类型具有相同的表示形式，也不应具有相同的等级。
—有符号整数类型的等级应大于精度较低的任何有符号整数类型的等级。
—的等级long long int应大于的等级long int，后者的等级应大于的等级int，后者的等级应大于的等级short int，等级应大于的等级signed char。
—任何无符号整数类型的等级应等于相应的有符号整数类型的等级（如果有）。 —字符的等级应等于有符号字符和无符号字符的等级。
—任何标准整数类型的等级应大于宽度相同的任何扩展整数类型的等级。

— _Bool的等级应小于所有其他标准整数类型的等级。
—任何枚举类型的等级应等于兼容整数类型的等级（见6.7.2.2）。

来自stdint.h这里的排序类型也与它们在给定系统上对应的任何类型具有相同的等级。例如，int32_t具有与int32位系统相同的等级。

此外，C11 6.3.1.1指定哪些类型被视为小整数类型（不是形式术语）：

在可以使用int或的表达式中unsigned int可以使用以下代码：

-一个整型（比其他的物体或表达int或unsigned int），其整数转换秩小于或等于的秩int和unsigned int。

什么在实践中，这种略带神秘文字的手段，是_Bool，char和short（也int8_t，uint8_t等等）是“小整数类型”。如下所述，这些内容将以特殊方式处理并受到隐式提升。

整数促销

每当在表达式中使用小整数类型时，它都会隐式转换int为始终带有符号的形式。这称为整数提升或整数提升规则。

正式而言，规则说（C11 6.3.1.1）：

如果anint可以代表原始类型的所有值（受位字段的宽度限制），则该值将转换为an int。否则，它将转换为unsigned int。这些称为整数促销。

这意味着，所有带符号的小整数类型，int在大多数表达式中使用时，都会隐式转换为（带符号）。

该文本经常被误解为：“所有小的带符号整数类型都转换为带符号int，所有小的带符号整数类型都转换为无符号int”。这是不正确的。这里的无符号部分仅意味着，如果我们有一个unsigned short操作数，并且int碰巧short与给定系统上的大小相同，则该unsigned short操作数将转换为unsigned int。在这种情况下，什么都没有真正发生。但是，如果short类型小于int，则始终将其转换为（signed）int，而不管short是带符号的还是无符号的！

整数提升导致的严酷现实意味着，几乎无法在Cchar或C等小型类型上执行C中的运算short。操作始终在int较大的类型上执行。

这听起来像是胡说八道，但是幸运的是编译器被允许优化代码。例如，包含两个unsigned char操作数的表达式会将操作数提升为int，并将操作执行为int。但是，可以预期，编译器可以优化表达式以实际以8位运算的形式执行。然而，这里来了问题：编译器不容许优化出引起整数推广符号性的隐含变化。因为编译器无法判断程序员是否故意依赖隐式升级，还是非故意的。

这就是为什么问题中的示例1失败的原因。这两个无符号char操作数都被提升为type int，对type进行运算int，并且结果x - y为type int。意味着我们得到的-1不是255预期的。编译器可能会生成使用8位指令（而不是8位指令）执行代码的机器代码int，但可能无法优化签名的更改。这意味着我们最终得到一个否定的结果，这反过来导致在printf("%u调用时产生一个怪异的数字。可以通过将运算结果转换回type来固定示例1 unsigned char。

除++和sizeof运算符之类的一些特殊情况外，整数提升适用于C中几乎所有的运算，无论是否使用一元，二进制（或三元）运算符。

通常的算术转换

每当在C中执行二进制运算（带有2个操作数的运算）时，运算符的两个操作数都必须具有相同的类型。因此，在操作数为不同类型的情况下，C强制将一个操作数隐式转换为另一操作数的类型。如何完成此操作的规则称为通常的人工转换（有时非正式地称为“平衡”）。这些在C11 6.3.18中指定：

（将此规则视为长的嵌套if-else if语句，可能更容易阅读:)）

6.3.1.8常规算术转换

许多期望算术类型的操作数的运算符都以类似的方式引起转换并产生结果类型。目的是确定操作数和结果的通用实型。对于指定的操作数，每个操作数在不更改类型域的情况下被转换为其对应的实型为普通实型的类型。除非另有明确说明，否则普通实型也是结果的对应实型，如果操作数相同，则其类型域是操作数的类型域，否则为复杂。这种模式称为通常的算术转换：

• 首先，如果一个操作数的对应实型为long double，则另一个操作数在不改变类型域的情况下转换为其对应实型为的类型long double。
• 否则，如果一个操作数的对应实型为double，则另一个操作数将被转换为对应实型为的类型，而不会改变类型域double。
• 否则，如果任一操作数的对应实型为float，则另一个操作数将在不更改类型域的情况下转换为其对应实型为float的类型。

• 否则，将对两个操作数执行整数提升。然后，将以下规则应用于提升后的操作数：

  • 如果两个操作数具有相同的类型，则无需进一步转换。
  • 否则，如果两个操作数都具有符号整数类型或都具有无符号整数类型，则将具有较小整数转换等级的操作数转换为具有较大等级的操作数的类型。
  • 否则，如果具有无符号整数类型的操作数的秩大于或等于另一个操作数的类型的秩，则将带符号整数类型的操作数转换为无符号整数类型的操作数的类型。
  • 否则，如果带符号整数类型的操作数的类型可以表示带无符号整数类型的操作数的所有值，则带无符号整数类型的操作数将转换为带符号整数类型的操作数的类型。
  • 否则，两个操作数都将转换为与带符号整数类型的操作数类型相对应的无符号整数类型。

这里值得注意的是，通常的算术转换适用于浮点数和整数变量。对于整数，我们还可以注意到，整数提升是从常规算术转换中调用的。之后，当两个操作数的秩至少int为时，运算符将被平衡为具有相同符号的相同类型。

这就是a + b示例2中给出奇怪结果的原因。这两个操作数都是整数，并且至少为rank int，因此整数提升不适用。操作数是不一样的类型-a是unsigned int和b是signed int。因此，运算符b将临时转换为type unsigned int。在此转换过程中，它会丢失符号信息，并最终变成较大的值。

之所以将short示例3中的类型更改为固定的问题，是因为short是一个小的整数类型。这意味着两个操作数都是整数，提升int为带符号的类型。整数提升后，两个操作数具有相同的类型（int），无需进一步转换。然后可以按预期对带符号的类型执行该操作。

根据上一篇文章，我想提供有关每个示例的更多信息。

示例1）

int main(){
    unsigned char x = 0;
    unsigned char y = 1;
    printf("%u\n", x - y); 
    printf("%d\n", x - y);
}

由于unsigned char小于int，因此我们对它们应用整数提升，因此我们有（int）x-（int）y =（int）（-1）和unsigned int（-1）= 4294967295。

上面代码的输出：（与我们的预期相同）

4294967295
-1

如何解决？

我尝试了上一篇文章的建议，但实际上没有用。这是基于前一篇文章的代码：

将其中之一更改为unsigned int

int main(){
    unsigned int x = 0;
    unsigned char y = 1;
    printf("%u\n", x - y); 
    printf("%d\n", x - y);
}

由于x已经是无符号整数，因此我们仅将整数提升应用于y。然后我们得到（unsigned int）x-（int）y。由于它们仍然没有相同的类型，因此我们应用通常的算术转换，得到（unsigned int）x-（unsigned int）y = 4294967295。

上面代码的输出：（与我们的预期相同）：

4294967295
-1

同样，以下代码获得相同的结果：

int main(){
    unsigned char x = 0;
    unsigned int y = 1;
    printf("%u\n", x - y); 
    printf("%d\n", x - y);
}

将它们都更改为unsigned int

int main(){
    unsigned int x = 0;
    unsigned int y = 1;
    printf("%u\n", x - y); 
    printf("%d\n", x - y);
}

由于它们都是unsigned int，因此不需要整数提升。通过通常的算术收敛（具有相同的类型），（unsigned int）x-（unsigned int）y = 4294967295。

上面代码的输出：（与我们的预期相同）：

4294967295
-1

修复代码的一种可能方法：（最后添加类型强制转换）

int main(){
    unsigned char x = 0;
    unsigned char y = 1;
    printf("%u\n", x - y); 
    printf("%d\n", x - y);
    unsigned char z = x-y;
    printf("%u\n", z);
}

上面代码的输出：

4294967295
-1
255

示例2）

int main(){
    unsigned int a = 1;
    signed int b = -2;
    if(a + b > 0)
        puts("-1 is larger than 0");
        printf("%u\n", a+b);
}

由于它们都是整数，因此不需要整数提升。通过通常的算术转换，我们得到（unsigned int）a +（unsigned int）b = 1 + 4294967294 = 4294967295。

上面代码的输出：（与我们的预期相同）

-1 is larger than 0
4294967295

如何解决？

int main(){
    unsigned int a = 1;
    signed int b = -2;
    signed int c = a+b;
    if(c < 0)
        puts("-1 is smaller than 0");
        printf("%d\n", c);
}

上面代码的输出：

-1 is smaller than 0
-1

示例3）

int main(){
    unsigned short a = 1;
    signed short b = -2;
    if(a + b < 0)
        puts("-1 is smaller than 0");
        printf("%d\n", a+b);
}

最后一个示例解决了该问题，因为由于整数提升，a和b都转换为int。

上面代码的输出：

-1 is smaller than 0
-1

如果我混淆了一些概念，请告诉我。谢谢〜