---

10.操作符的属性：优先级、结合性

10.1 优先级

这里的优先级，我们是考虑相邻的操作符。

相邻的操作符，优先级高的先执行。

我们可以用（）来改变优先级。

---

10.2 结合性

如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了。

就看是从左向右算还是从右向左算。

---

11.表达式求值

11.1 整型提升

整型提升讨论的是表达式中char和short类型的值。

C语言中整型算术运算总是至少以缺省（默认）整型类型的精度来进行的。

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

表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

如何进行整体提升呢？

1. 有符号整数提升是按照变量的数据类型的符号位来提升的
2. 无符号整数提升，高位补0

int main() {
	char a = 20;
    //00010100 - a
    //00000000000000000000000000010100 - a
	char b = 130;
    //10000010 - b
    //00000000000000000000000010000010 - b
	char c = a + b;
    //00010100 - a（符号位是0）
    //00000000000000000000000000010100 - a整型提升（补码）
    //10000010 - b（符号位是1）
    //11111111111111111111111110000010 - b整型提升（补码）
    //11111111111111111111111110010110 - c（补码）
    //10010110 - c（截断）
    //%d - 打印有符号的整数
    //11111111111111111111111110010110 - c整型提升（补码）
    //10000000000000000000000001101001 - c（反码）
    //10000000000000000000000001101010 - c（原码）：-106
	printf("%d\n", c);
    
	return 0;
}

打印：

-106

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

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

---

11.2 算术转换

算数转换讨论的是类型大于等于整型类型的其他类型。

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

1. long double

2. double

3. float

4. unsigned long int

5. long int

6. unsigned int

7. int

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

---

11.3 问题表达式解析

11.3.1 表达式1

你觉得先算什么呢?

a*b + c*d + e*f

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

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

1. a*b
2. c*d
3. ab + cd
4. e*f
5. ab + cd + e*f

或者：

1. a*b
2. c*d
3. e*f
4. ab + cd
5. ab + cd + e*f

---

11.3.2 表达式2

c + --c;

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

例如：

int c = 5;

–c是先算的，算完后c=4，那么左边的c会不会也随之改变值呢？

那么是5+4还是4+4呢？

---

11.3.3 表达式3

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

这个和表达式二有点像，而且不方便读写。

表达式3在不同编译器中测试结果也不一样。

---

11.3.4 表达式4

#include <stdio.h>
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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。

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

---

11.3.5 表达式5:

#include <stdio.h>
int main()
{
    int i = 1;
    int ret = (++i) + (++i) + (++i);
    printf("%d\n", ret);
    printf("%d\n", i);
    return 0;
}

同样的代码在不同编译器产生了不同的结果。

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

---

11.4 总结

即使有了操作符的优先级和结合性，我们写出的表达式依然有可能不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在潜在风险的，建议不要写出特别复杂的表达式。