本文旨在作为关于C语言中隐式整型提升的常见问题解答，特别是由于通常算术转换和/或整型提升导致的隐式提升。
示例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可以解决问题？
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位计算机。）
这里也包括了stdint.h中的类型，它们与给定系统上对应的类型具有相同的等级。例如，在32位系统上，int32_t与int具有相同的等级。
此外，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）：
如果
int类型可以表示原始类型的所有值（受位域的宽度限制），则将值转换为int；否则，将其转换为unsigned int。这被称为整数提升。
这意味着所有小整数类型，无论有无符号，当在大多数表达式中使用时，都会被隐式转换为（带符号的）int。
unsigned short的操作数，并且int恰好在给定系统上与short具有相同的大小，那么unsigned short操作数将被转换为unsigned int。也就是说，没有什么特别的事情发生。但是，如果short是比int更小的类型，它总是被转换为（有符号的）int，而不管short是有符号还是无符号！char或short这样的小类型进行任何操作。操作总是在int或更大的类型上进行。unsigned char操作数的表达式会将操作数提升为int，并进行int操作。但编译器可以优化表达式，使其实际上作为一个8位操作执行，这是可以预期的。然而，问题来了：编译器不允许优化由整数提升引起的隐式符号更改，因为编译器无法判断程序员是有意依赖隐式提升，还是无意之间发生了这种情况。int类型，操作是在int类型上进行的，x - y的结果是int类型。这意味着我们得到的是-1而不是可能期望的255。编译器可能会生成使用8位指令执行代码的机器码，而不是int，但它可能不会优化掉符号的改变。这意味着我们最终得到一个负数的结果，当调用printf("%u时，会得到一个奇怪的数字。通过将操作的结果强制转换回unsigned char类型，可以修复示例1。++和sizeof运算符，整数提升适用于C中几乎所有的操作，无论是一元、二元（或三元）运算符。
在C语言中，每当进行二元操作（即涉及两个操作数的操作）时，操作符的两个操作数必须是相同的类型。因此，如果操作数的类型不同，C语言会强制将其中一个操作数隐式转换为另一个操作数的类型。这种转换的规则被称为通常的算术转换（有时非正式地称为"平衡"）。这些规则在C11 6.3.18中进行了详细说明：
（将这个规则想象成一个长而嵌套的if-else if语句，可能更容易理解 :) ）
许多期望算术类型操作数的运算符会进行转换，并以类似的方式产生结果类型。其目的是确定操作数和结果的共同实际类型。对于指定的操作数，每个操作数都会被转换为一个类型，其对应的实际类型是共同的实际类型，而不改变类型域。除非另有明确说明，否则共同的实际类型也是结果的对应实际类型，其类型域与操作数相同，如果它们相同，则为复数。这种模式被称为“通常的算术转换”。6.3.1.8 通常的算术转换
double，则另一个操作数将被转换为相应实际类型为double的类型，而不改变类型域。float，则另一个操作数将被转换为相应实际类型为float的类型，而不改变类型域。a + b会得到一个奇怪的结果的原因。两个操作数都是整数，并且它们至少是int级别，因此不会进行整数提升。这两个操作数的类型不同 - a是unsigned int，而b是signed int。因此，操作数b会被临时转换为unsigned int类型。在这个转换过程中，它失去了符号信息，最终变成了一个很大的值。short可以解决这个问题的原因是short是一个小的整数类型。这意味着两个操作数都会被整数提升为int类型，而int是有符号的。在整数提升之后，两个操作数具有相同的类型（int），不需要进一步的转换。然后，操作可以按预期在有符号类型上执行。(unsigned char)，如(unsigned char)(x-y)：这将给OP期望的255。然而，人们经常忽视向较小的大小进行强制转换，但这是实现截断的正确方法（随后将跟随隐式/自动有符号或零扩展到~int大小）。 - Erik Eidtint32_t 等）。 - Ian Abbottint 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)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);
}
-1 is smaller than 0
-1
signed int c = a+b;引发了未定义行为。a+b的结果类型是无符号的，计算出的值超出了有符号整数的范围。 - Chesharint类型的大小做出了不必要的假设。 - M.MI tried what the previous post recommended, but it doesn't really work. Here is the code based on the previous post: change one of them to unsigned int. No, the main answer says: Example 1 could be fixed by casting the result of the operation back to type unsigned char. So, they mean to do this, which does work to provide the expected result of 255!: printf("%u\n", (unsigned char)(x - y)); // Output: 255 - Gabriel Staples我想试着概括一下这些规则，以便我可以快速参考它们。我已经完全研究了问题和其他两个答案，包括 @Lundin 的主要答案。如果你想要更多例子，超出以下的例子，请也详细研究那个答案，并参考我的"规则"和"提升流程"概述。
我还在这里写了自己的示例和演示代码：integer_promotion_overflow_underflow_undefined_behavior.c。
尽管我通常非常啰嗦，但我会尽量保持这篇简短摘要，因为其他两个答案加上我的测试代码已经有足够详细的内容。
uint8_t x = 0;
uint8_t y = 1;
提升规则如下。从最小到最大类型的提升如下所示。
将"-->"解读为"被提升为"
方括号中的类型（例如：[int8_t]）是典型的"固定宽度整数类型"，适用于典型的64位Unix（Linux或Mac）架构。例如，请参考：
bool (_Bool)，char [int8_t]，unsigned char [uint8_t]，short [int16_t]，unsigned short [uint16_t]。
小类型： bool (_Bool)，char [int8_t]，unsigned char [uint8_t]，short [int16_t]，unsigned short [uint16_t]int [int32_t]unsigned int [uint32_t]long int [int64_t]unsigned long int [uint64_t]long long int [int64_t]unsigned long long int [uint64_t]
指针（例如：void*）和size_t都是64位，所以我想它们适用于上面的uint64_t类别。float [32位] --> double [64位] --> long double [128位]
另请参阅
exp的类型是uint32_t。for (int32_t i = 22; i >= MAX(22 - exp + 1, 0); i--) {
...
}
unsigned short a = 1;
signed short b = -2;
if(a + b > 0)
puts("-1 is larger than 0"); // will not print
被-Wsign-conversion捕获，也包含在-Wextra中。在我的代码库中，这个标志产生了大约40个警告，所有这些警告都是完全无害的，不值得费力去修复。
不幸的是，无论是gcc还是clang都没有警告来标记“可疑”的类型提升，但会保留安全的提升（例如for (int i = 0; i < strlen(s); i++)）。
您可能想阅读朋友们不要使用“-W”以获取关于何时使用和何时不使用编译器警告标志的（知情的）意见。
我想对@Lundin的回答中的示例1进行两点澄清，其中有两个相同整数类型的操作数，但是它们是需要整数提升的“小类型”。
我正在使用N1256 draft，因为我没有付费版的C标准。
首先：（规范性）
6.3.1.1对整数提升的定义并不是实际执行整数提升的触发子句。实际上，它是6.3.1.8通常算术转换。
大多数情况下，“通常的算术转换”适用于操作数是不同类型的情况，在这种情况下，至少需要提升一个操作数。但问题在于，对于整数类型，所有情况都需要整数提升。
[浮点类型的子句首先处理]EXAMPLE 2 In executing the fragment
char c1, c2; /* ... */ c1 = c1 + c2;the "integer promotions" require that the abstract machine promote the value of each variable to
intsize and then add the twoints and truncate the sum. Provided the addition of twochars can be done without overflow, or with overflow wrapping silently to produce the correct result, the actual execution need only produce the same result, possibly omitting the promotions.
printf("%u\n", x - y);会导致未定义行为。 - M.M~((u8)(1 << 7))添加到列表中，这是一个不错的例子。 - 0andriy