整型提升+算术转换——“C”

各位CSDN的uu们你们好呀，今天小雅兰的内容是之前操作符那篇博客中没有讲完的内容，整型提升这个小知识点也非常重要，那现在，就让我们进入操作符的世界吧

---

隐式类型转换

算术转换

操作符的属性

---

 隐式类型转换

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

这一规则是由C语言的发明人丹尼斯·里奇与肯·汤普逊创设的：

"A character, a short integer, or an integer bit-field, all either signed or not, or an object of enumeration type, may be used in an expression wherever an integer maybe used. If an int can represent all the values of the original type, then the value is converted to int; otherwise the value is converted to unsigned int. This process is called integral promotion."

这段话的大意是：表达式中可以使用整数的地方，就可以使用枚举类型，或有符号或无符号的字符、短整数、整数位域。如果一个int可以表示上述类型，则该值被转化为int类型的值；否则，该值被转化为unsigned int类型的值。这一过程被称作integral promotion。

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令 中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。

C语言标准中仅规定了：

char的长度 ≤ short int的长度 ≤ int的长度

这意味着short int与int的长度相等的可能。这种情形下，unsigned short就无法提升为int表示，只能提升为unsigned int。

char a;
char b;
char c;
c=a+b;

 b和a的值被提升为普通整型，然后再执行加法运算。

加法运算完成之后，结果将被截断，然后再存储于a中。

说了这么久整型提升，那么，究竟怎样进行整型提升呢？

整型提升是按照变量的数据类型的符号位来提升的。

int main()

{

   char a=3;

   //00000000000000000000000000000011——3的二进制

   //但是，这是一个char类型的变量，会发生截断

   //00000011——截断

   char b=127;

   //00000000000000000000000001111111——127的二进制

   //01111111——截断

   char c=a+b;

   //00000011

   //011111111

   //整型提升

   //00000000000000000000000000000011

   //00000000000000000000000001111111

   //相加

   //00000000000000000000000010000010

   //10000010——截断

   printf("%d\n",c);

   //但是以%d的形式打印，所以c又要发生整型提升

   //按照变量的数据类型的符号位来提升

   //11111111111111111111111110000010——补码

   //11111111111111111111111110000001——反码

   //10000000000000000000000001111110——原码

   //所以最后的结果是-126

   return 0;

}

//负数的整型提升char c1 = -1;//变量c1的二进制位(补码)中只有8个比特位：//1111111//因为 char 为有符号的 char//所以整型提升的时候，高位补充符号位，即为1//提升之后的结果是：//11111111111111111111111111111111//正数的整型提升char c2 = 1;//变量c2的二进制位(补码)中只有8个比特位：//00000001//因为 char 为有符号的 char//所以整型提升的时候，高位补充符号位，即为0//提升之后的结果是：//00000000000000000000000000000001//无符号整型提升，高位补0

下面，我们来看一下整型提升的具体例子

int main()
{char a = 0xb6;short b = 0xb600;int c = 0xb6000000;if(a==0xb6)printf("a");if(b==0xb600)printf("b");if(c==0xb6000000)printf("c");return 0;
}

 我们会发现，打印结果最后只有c

 因为：

  a,b要进行整型提升,但是c不需要整型提升

  a,b整型提升之后,变成了负数,所以表达式 a==0xb6 , b==0xb600的结果是假,但是c不发生整型提升,则表达式 c==0xb6000000 的结果是真

int main()
{char c = 1;printf("%u\n", sizeof(c));printf("%u\n", sizeof(+c));printf("%u\n", sizeof(-c));return 0;
}

 c只要参与表达式运算,就会发生整型提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字节。

 表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节。

 但是 sizeof(c) ,就是1个字节。

---

算术转换

大多数 C 运算符执行类型转换以将表达式的操作数引入常见类型或将较短的值扩展到计算机运算中使用的整数大小。

C 运算符执行的转换取决于特定的运算符和操作数的类型。

但是，许多运算符对整型和浮点型的操作数执行相似的转换。

这些转换称为“算术转换”。

从操作数值到兼容类型的转换会导致不改变其值。

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。

下面的层次体系称为寻常算术转换。

long double

double

float

unsigned long int

long int

unsigned int

int

 如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。

• 如果任一操作数是 long double 类型，则将另一个操作数转换为 long double 类型。
• 如果上述一个条件不满足，且其中一个操作数的类型为 double，则另一个操作数被转换为 double 类型。
• 如果上述两个条件不满足，且其中一个操作数的类型为 float，则另一个操作数被转换为 float 类型。
• 如果未满足上述三个条件（所有操作数都不是浮点型），则对操作数执行整型转换，如下所示：

• 如果任一操作数是 unsigned long 类型，则将另一个操作数转换为 unsigned long 类型。
• 如果上述一个条件不满足，且其中一个操作数的类型为 long 类型，另一个操作数的类型为 unsigned int，则这两个操作数都被转换为 unsigned long 类型。
• 如果上述两个条件不满足，且其中一个操作数的类型为 long，则另一个操作数被转换为 long 类型。
• 如果未满足上述三个条件，并且任一操作数是 unsigned int类型，则将另一个操作数转换为 unsigned int 类型。
• 如果未满足上述任何条件，则将两个操作数转换为 int 类型。

但是算术转换要合理，要不然会有一些潜在的问题。 

float f = 3.14;
int num = f;//隐式转换，会有精度丢失

---

操作符的属性 

复杂表达式的求值有三个影响的因素。

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

两个相邻的操作符先执行哪个？

   取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

下面，我们来看看操作符的优先级，这是一张表：

 

 

 在了解了操作符的优先级之后，有些人就可能会突发奇想，写出一些稀奇古怪的表达式，写出来不仅是坑自己，也是坑队友！！！

猪队友表达式1：

a*b + c*d + e*f

对于这行代码，如果仅由优先级决定这个表达式的求值顺序，那么所有三个乘法运算将在所有加法运算之前进行。事实上，这个顺序不是必需的。实际上只要保证每个乘法运算在它相邻的的加法运算之前执行即可。

这个执行顺序可能是这样的：

• a*b
• c*d
• a*b + c*d
• e*f
• a*b + c*d + e*f

还有另外一种可能是这样： 

• a*b
• c*d
• e*f
• a*b + c*d
• a*b + c*d + e*f

这就是一个典型的问题表达式，写出来就是猪队友！！！

猪队友表达式2：

c + --c;  

操作符的优先级规则只要求自减运算在加法运算之前进行，但我们并没有办法得知加法操作符的左操作数是在右操作数之前还是之后进行求值。它在这个表达式中将存在区别，因为自减操作符具有副作用，--c在c之前或之后执行，表达式的结果在两种情况下将会不同。

猪队友表达式3：

int main()

{

   int i = 10;

   i = i-- - --i * ( i = -3 ) * i++ + ++i;

   printf("i = %d\n", i);

   return 0;

}

这也是一个猪队友表达式，试想：这样的表达式，写出来就是为祸人间！！！

《C和指针》的作者Kenneth A.Reek老师专门研究了这串代码，并在各种不同的编译器下运行出了各种不同的结果。

 猪队友表达式4：

int fun()

{  

  static int count = 1;  

  return ++count;

}

int main()

{  

  int answer;  

  answer = fun() - fun() * fun();  

  printf( "%d\n", answer);//输出多少？

  return 0;

}

虽然在大多数的编译器上求得结果都是相同的。

但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法， 再算减法。

函数的调用先后顺序无法通过操作符的优先级确定。

就是说：调用fun函数要调用3次，第一次fun函数的调用结果为2，第二次fun函数的调用结果为3，第三次fun函数的调用结果为4，但是顺序是不确定的。

• 可能是2-3*4
• 可能是3-2*4
• 可能是4-2*3

 猪队友表达式5：

#include<stdio.h>

int main()

{

  int i = 1;

  int ret = (++i) + (++i) + (++i);

  printf("%d\n", ret);

  printf("%d\n", i);

  return 0;

}

尝试在linux 环境gcc编译器，VS2022环境下都执行，看结果。

 

 VS2022环境的结果：

 这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第 三个前置 ++ 的先后顺序。

总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

---

好啦，小雅兰今天的内容就到这里啦，又是一篇拖了好久的博客，小雅兰以后的时间可能就没那么多了，今天，开学考试所有的科目就都已经结束，从明天开始，就要正式上课啦，星期一第一节课就是电路分析，这是破大防了！！！小雅兰以后也会一直努力学C语言和数据结构的！！！