深入理解隐式类型转换

一、隐式类型转换的规则

在C语言中，自动类型转换遵循以下规则：

1. 若参与运算量的类型不同，则先转换成同一类型，然后进行运算。
2. 转换按数据长度增加的方向进行，以保证精度不降低。如int型和long型运算时，先把int量转成long型后再进行运算。
   a、若两种类型的字节数不同，转换成字节数高的类型
   b、若两种类型的字节数相同，且一种有符号，一种无符号，则转换成无符号类型
3. 所有的浮点运算都是以双精度进行的，即使仅含float单精度量运算的表达式，也要先转换成double型，再作运算。
4. char型和short型参与运算时，必须先转换成int型。
5. 在赋值运算中，赋值号两边量的数据类型不同时，赋值号右边量的类型将转换为左边量的类型。如果右边量的数据类型长度比左边长时，将丢失一部分数据，这样会降低精度，丢失的部分按四舍五入向前舍入。

二、整型提升

1.提升的原因

C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。

2.提升的意义

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

3.如何进行提升

整型提升（隐式转换的一种）是按照变量自身的数据类型的符号位提升的。
原理：有符号补符号位；无符号无脑补0。

---

1. 负数的整形提升
   char c1 = -1;
   变量c1的二进制位(补码)中只有8个比特位：
   1111 111
   因为 char 为有符号的 char
   所以整形提升的时候，高位补充符号位，即为1
   提升之后的结果是：
   1111 1111 1111 1111 1111 1111 1111 1111

2. 正数的整形提升
   char c2 = 1;
   变量c2的二进制位(补码)中只有8个比特位：
   0000 0001
   因为 char 为有符号的char
   所以整形提升的时候，高位补充符号位，即为0
   提升之后的结果是：
   0000 0000 0000 0000 0000 0000 0000 0001

3. 无符号整形提升，高位补0

4.整型提升的例子

例1：
很棒的一道题

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的结果是真.
例2：

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

实例2中的,c只要参与表达式运算,就会发生整形提升,表达式+c ,就会发生提升,所以 sizeof(+c)是4个字节.
表达式 -c也会发生整形提升,所以sizeof(-c)是4个字节,但是sizeof(c) ,就是1个字节.

三、算术转换

1.如何进行转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。

如果在同一个运算当中的操作数类型不一样，等级较低的都往等级较高的转换。
注意：
但是算术转换要合理，要不然会有一些潜在的问题

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

2.例题

int main(void)
{
	unsigned char a = 0;
	unsigned char b = 255;
	unsigned char c = 255;
	a = b + c;
	printf("a = %d\n", a);
	return 0;
}

输出结果：

分析：

b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
注意：

char a = 10;
printf("%d,a);
int b = a;

这也是函数，传参就要发生值拷贝，就要用到CPU，也同样要发生隐式转换。

3.总结

为什么要发生转换

硬件：CPU寄存器的比特位是统一的，将内存中的数据放入寄存器中就会发生隐式转换
软件：c语言的操作符对多个操作数进行操作时，必须保证其类型一致

四、操作符的属性

1.操作符

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

1. 操作符的优先级。决定了有多个操作符和多个操作数时，先执行那部分。
2. 操作符的结合性。当优先级相同，多个或单个操作符之间从左向右执行还是从右向左执行。
3. 是否控制求值顺序。特定的某些表达式在进行求值，根据不同的条件产出不同的求值过程。

两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。

操作符优先级，从上往下
重点要记住的几个

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
（）	聚组	（表达式）	与表达式同	N/A	否
.	访问结构成员	lexp.member_name	lexp	L-R	否
->	访问结构指针成员	rexp->member_name	lexp	L-R	否
++	后缀自增	lexp ++	rexp	L-R	否
- -	后缀自减	lexp - -	rexp	L-R	否
++	前缀自增	++lexp	rexp	R-L	否
- -	前缀自减	- - lexp	rexp	R-L	否
*	间接访问	* rexp	lexp	R-L	否

2.问题表达式

表达式1
a*b + c*d + e*f

注释：代码1在计算的时候，由于的优先级比+的优先级高，只能保证的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。

所以表达式的计算机顺序就可能是：

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;

同上，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预的,是有歧义的。

---

代码3-非法表达式

int main()
{
	int i = 10;
	i = i-- - --i * (i = -3) * i++ + ++i;
	printf("i = %d\n", i);
	return 0;
}

表达式3在不同编译器中测试结果：非法表达式程序的结果
在vs2013中结果为

4

在linux中结果为

36

---

代码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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。

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