完全自学C(干货) —— 操作符（二）

目录

一，操作符的属性

二，隐式类型转换

三，算术转换

---

表达式求值

• 表达式求值的顺序，由操作符的优先级和结合性决定。
• 有些表达式的操作数在求值的过程中，可能需要类型转换（转换为其他类型）。

一，操作符的属性

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

• 1. 操作符的优先级（可查看文章末尾的优先级表格）；
• 2. 操作符的结合性（两者的优先级相同，取决于他们的结合性）；
• 3. 是否控制求值顺序；

问题表达式

int main()
{
	int a, b, c, d, e, f;
	a * b + c * d + e * f;
	//由于*的优先级比+高，所以可能的计算顺序有：
	//可能1：先分别算(a * b),(c * d)在(a * b)+(c * d)，在计算e * f，最后((a * b)+(c * d)) + (e * f)
	//可能2：先分别算(a * b),(c * d),(e * f)在把结果相加(a * b) + (c * d) + (e * f)

	c + --c;
	//--的优先级高于+
	//但+操作符，左操作数的获取是在右操作数之前还是之后求值，会有歧义；
	return 0;
}

int fun()
{
    static int count = 1;
    return ++count;
}

int main()
{
    int answer;
    //以下表达式，只能判断先算*在算-，但fun()函数调用顺序无法确定，故也会发生歧义
    answer = fun() - fun() * fun();
    printf("%d\n", answer);
    return 0;
}

总结：如果表达式不能通过操作符的属性确定唯一的计算路径，那就是问题表达式；

二，隐式类型转换

整型提升

• 表达式中字符(char)和短整型(short)操作数，在使用之前被转换为普通整型，称为整型提升；
• CPU内整型运算器(ALU)的操作数的字节长度，一般就是int的字节长度，所以小于整型长度的都会先转换为整型；

int main()
{
	char a, b, c;
	a = b + c;
	//先将b,c提升为整型，然后相加计算
	//计算结果，在截断为char长度，存入a
	return 0;
}

整型提升规则

• 负数整型提升，不足的高位全部补充符号位1；
• 正数整型提升，不足的高位全部补充符号位0；
• 无符号整型提升，不足的高位全部补充0；

int main()
{
	//负整数整型提升
	char a = -1;
	//1111 1111 - 字符型a的内存形式
	//1111 1111 1111 1111 1111 1111 1111 1111 - 由于负数高位补1

	//正整数整型提升
	char b = 1;
	//0000 0001 - 字符型a的内存形式
	//0000 0000 0000 0000 0000 0000 0000 0001 - 由于正数高位补0

	//无符号整型提升
	unsigned char c = 1;
	//0000 0001 - 字符型a的内存形式
	//0000 0000 0000 0000 0000 0000 0000 0001 - 由于无符号数高位补0
}

int main()
{
	char a = 0xb6; //十六进制形式,一个字节
	short b = 0xb600; //十六进制形式,两个字节
	int c = 0xb6000000; //十六进制形式,四个字节

	if (0xb6 == a)
		printf("a");
	//1011 0110 - 字符型a内存形式
	//1111 1111 1111 1111 1111 1111 1011 0110 - 整型提升后的内存形式
	//此时a已变为0xffffffb6

	if (0xb600 == b)
		printf("b");
	//1011 0110 0000 0000 - 短整型a内存形式
	//1111 1111 1111 1111 1011 0110 0000 0000 - 整型提升后的内存形式
	//此时a已变为0xffffb600

	if (0xb6000000 == c)
		printf("c");
	//无需整型提升

	return 0;
}
//结果：c

int main()
{
	char c = 1;
	printf("%u\n", sizeof c); //1
	printf("%u\n", sizeof +c); //4，转型提升；
	printf("%u\n", sizeof -c); //4，转型提升；
	printf("%u\n", sizeof !c); //1，vs编译器处理后的结果，应该是4；
	return 0;
}
//任何变量或表达式都有两个属性，值属性、类型属性（可推导出）；

三，算术转换

如操作符的操作数属于不同的类型，其中的一个操作数需转换为另一个操作数，才能进行运算；

下表中，越低则需转换：

long double

bouble

float

unsigned long int

long int

unsigned int

int

int main()
{
	float a = 3.14;
	int b = 1;
	float c = a + b; //b先转换为float在相加，a + (flaot)b
	printf("%f", c);
}

优先级表格

操作符	描述	结合性	是否控制求值顺序
（）	括号	N/A	否
（）	函数调用	L-R	否
[ ]	下标引用	L-R	否
.	结构体成员访问	L-R	否
->	结构体成员访问	L-R	否
++	后缀自增	L-R	否
--	后缀自减	L-R	否
！	逻辑反	R-L	否
~	按位取反	R-L	否
+	正号	R-L	否
-	负号	R-L	否
++	前缀自增	R-L	否
--	前缀自减	R-L	否
*	解引用	R-L	否
&	取地址	R-L	否
sizeof	求字节长度	R-L	否
（类型）	强制类型转换	R-L	否
*	乘法	L-R	否
/	除法	L-R	否
%	求余	L-R	否
+	加法	L-R	否
-	减法	L-R	否
<<	左移位	L-R	否
>>	右移位	L-R	否
>	大于	L-R	否
>=	大于等于	L-R	否
<	小于	L-R	否
<=	小于等于	L-R	否
==	等于	L-R	否
!=	不等于	L-R	否
&	按位与	L-R	否
^	按位异或	L-R	否
|	按位或	L-R	否
&&	逻辑与	L-R	是
||	逻辑或	L-R	是
？：	条件操作符	N/A	是
=	赋值	R-L	否
+=	自加	R-L	否
-=	自减	R-L	否
*=	自乘	R-L	否
/=	自除	R-L	否
%=	自取余	R-L	否
<<=	自左移	R-L	否
>>=	自右移	R-L	否
&=	自按位与	R-L	否
^=	自按位异或	R-L	否
|=	自按位或	R-L	否
，	逗号	L-R	是