抽丝剥茧C语言（中阶）操作符+练习

操作符祥解

• 导语
• 操作符分类：
• • 1.算术操作符
  • 2. 移位操作符
  • • 2.1 左移操作符
    • 2.2 右移操作符
  • 3. 位操作符
  • 4. 赋值操作符
  • 5. 单目操作符
  • • 5.1 单目操作符介绍
    • 5.2 sizeof 和 数组
  • 6. 关系操作符
  • 7. 逻辑操作符
  • 8. 条件操作符
  • 9. 逗号表达式
  • 10. 下标引用、函数调用和结构成员
  • • 10.1 [ ] 下标引用操作符
    • 10.2 ( ) 函数调用操作符
    • 10.3 访问一个结构的成员
  • 11. 表达式求值
  • • 11.1 隐式类型转换
    • 11.2 算术转换
    • 11.3 操作符的属性
• 结束语

导语

这一篇会让你更加熟练合理的利用操作符，有一些代码是很坑爹的：
int i = 1;
int ret = (++i) + (++i) + (++i);
是不是很熟悉？
其实这个是个有问题的代码，至于是为什么？
我们往下看。

操作符分类： 1.算术操作符

+    -   *   /   %

这些都是我们常用的算术操作符，注意以下的三个点就好了。

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

2. 移位操作符

这两个操作符是关于二进制的问题。

<< 左移操作符
>> 右移操作符

注：移位操作符的操作数只能是整数。

2.1 左移操作符

移位规则：

左边抛弃、右边补0

我们来定义一个整型：
int num = 10;

10的二进制是这样的
00000000000000000000000000001010
向左位移1位（num<<1）
00000000000000000000000000010100
num = 20

当然，如果num没有被赋值，就无法使用位移操作符。

2.2 右移操作符

移位规则：
首先右移运算分两种：

1. 逻辑移位
   左边用0填充，右边丢弃
2. 算术移位
   左边用原该值的符号位填充，右边丢弃

至于到底是哪个？还要看我们的编译器。（这里用的是VS2022）
首先我们来定义一个整型，如果它是一个正数，按照两个规则，都是左边补零，毫无意义，所以我们要定义一个负数。
int num = -1;
我们之前了解过，最左边的是符号位，1是负数，0是整数。
正常来说，我们认为二进制应该是这样子的：

10000000000000000000000000000001

其实在内存中并不是这个样子的，我们把这种能人工转换成其他进制的叫做原码。我们内存当中存的是补码。
我们在原码转换成补码的时候还有一个反码的过程。

反码就是把除了符号位的其他部位都反过来，补码在反码的基础上加1就可以了。至于正数？正码反码补码全都相同。
现在我们来看代码：

#include 
int main()
{
	int a = -1;
	printf("%dn", a);
	a = a >> 1;//向右位移一位
	printf("%dn", a);
	return 0;
}

代码运行如下：

也就是说我们目前VS2022编译器用的是算数移位。
注意：对于移位运算符，不要移动负数位，这个是标准未定义的。

int num = 10;
num>>-1;//错误的

3. 位操作符

位操作符有：

& //按位与
| //按位或
^ //按位异或
注：他们的操作数必须是整数

这些操作符也是二进制方面的操作。
我们用代码举例：

#include 
int main()
{
 int num1 = 1;
 int num2 = 2;
 int a = num1 & num2;
 int b = num1 | num2;
 int c = num1 ^ num2;
 printf("%dn", a);
 printf("%dn", b);
 printf("%dn", c);
 return 0; 
}

代码运行的结果是这样的：

具体是怎么回事呢？
我们首先来看a：

按位与是两个整形变量相对应的二进制位如果有两个1就变成1，如果只有一个1或者是没有1那么只能是0。
也就是说我们a的二进制全都是0，那么a转换为十进制就是0。
b：

按位或是两个整形变量相对应的二进制位如果有一个或者是两个1就变成1，如果没有1只能是0。
b的二进制转换成十进制就变成了3。
c：

按位异或是两个整型变量，相应的二进制位值不同则为1，否则为0。
c的二进制转换成十进制是3。
有一道面试题就涉及到了位操作符：
不能创建临时变量（第三个变量），实现两个数的交换。
我们原本的方法是需要第三个变量来交换，这次却不可以，这道题的参考代码是：

#include 
int main()
{
 int a = 10;
 int b = 20;
 a = a ^ b;//一
 b = a ^ b;//二
 a = a ^ b;//三
 printf("a = %d b = %dn", a, b);
 return 0; 
}

过程是这样的：

一
a 001010
b 010100
a 100001
二
a 100001
b 010100
b 001010
三
a 100001
b 001010
a 010100

我们发现a^b^b=a这样一个情况，以后可以适当利用。
代码运行结果为：

20 10

再来一道让我们熟悉上面的操作符
求一个整数存储在内存中的二进制中1的个数。
我们有三种方法，参考代码如下：

//方法1
#include 
int main()
{
	int num = 10;
	int count = 0;//计数
	while (num)
	{
		if (num % 2 == 1)
			count++;
		num = num / 2;
	}
	printf("二进制中1的个数 = %dn", count);
	return 0;
}
//思考这样的实现方式有没有问题？
//方法2：
#include 
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	for (i = 0; i < 32; i++)
	{
		if (num & (1 << i))
			count++;
	}
	printf("二进制中1的个数 = %dn", count);
	return 0;
}
//思考还能不能更加优化，这里必须循环32次的。
//方法3：
#include 
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	while (num)
	{
		count++;
		num = num & (num - 1);
	}
	printf("二进制中1的个数 = %dn", count);
	return 0;
}

方法一：
10的二进制是1010
10模2是0
10/2=5
5的二进制是101
我们发现少了一个0，如果一直如下下去就等于右位移操作符的原理。
可是如果是负数呢？就造成了死循环。
方法二：
那么我们限制它的位数不就可以了吗？
我们知道32位系统就有32个比特位，32个二进制位。

i是1~31的数字，也就是说让1循环向左位移，一共循环32次，也就是说1的二进制中的1会在32个比特位上都会出现。
然后把你要算的整型按位与上面一直循环的1就可以了。

方法三：
这个方法真的难以想到，不过这样可以避免因为32位和64位系统位数从而导致不同的结果。
11111111111111111111111111111111
11111111111111111111111111111110
11111111111111111111111111111110

11111111111111111111111111111110
11111111111111111111111111111101
11111111111111111111111111111100

11111111111111111111111111111100
11111111111111111111111111111011
11111111111111111111111111111000

11111111111111111111111111111000
11111111111111111111111111110111
11111111111111111111111111110000
以此循环就能算出来二进制中有多少个1。

4. 赋值操作符

赋值操作符这是我们经常用的一个操作符，同时也是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋值。

double salary = 10000.0；//如果你对工资不满意，那就修改
salary = 30000.0；
int weight = 150;//体重
weight = 120;//不满意就赋值
//赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20; 
a = x = y+1;//连续赋值
//但是这样的代码读起来感觉不是很好，所以我们最好不要这样写
x = y+1;
a = x;
//这么写代码可读性才高

复合赋值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

这些运算符都可以写成复合的效果。
比如：

int x = 10; 
x = x+10; //和下面的表达式效果相同
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

5. 单目操作符

什么是单目操作符？就是需要一个操作数控制的操作符，比如说我们之前见过的&（取地址操作符）后面需要一个变量才能使用，后面的变量就是操作数。

5.1 单目操作符介绍

!           //逻辑反操作
-           //负值
+           //正值
&           //取地址
sizeof      //操作数的类型长度（以字节为单位）
~           //对一个数的二进制按位取反
--          //前置、后置--
++          //前置、后置++
*           //间接访问操作符(解引用操作符) (类型)       强制类型转换

关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
参考代码：

#include 
int main()
{
	int a = -10;
	int* p = NULL;
	printf("%dn", !2);
	printf("%dn", !0);
	a = -a;
	printf("%dn", a);
	p = &a;
	printf("%dn", *p);//解引用是把指针变量储存的地址给打开然后访问。这里就等于a
	printf("%dn", sizeof(a));
	printf("%dn", sizeof(int));
	printf("%dn", sizeof a);//这样写行不行？
	printf("%dn", sizeof int);//这样写行不行？
	return 0;
}

如果把这一段代码放在编译器里会发现sizeof int编译不过去，会给你报错，sizeof是一个操作符不是一个函数，可以后面省略括号，但是如果是计算数据类型只能加括号，这是语法规定！
我们把最后一段表达式注释掉，然后运行代码：

！号是逻辑反操作符。我们知道，非零是真，零是假。
！2是让真变成假，！0让假变成真，我们计算机默认真打印1，假打印0。
~是按位取反的操作符，也是关于二进制：
我们定义一个整型变量

#include 
int main()
{
	int a = -1;
	printf("%d", ~a);
	return 0;
}

这就是按位取反，这个会把符号位也取反。
还有前置和后置的符号：

#include 
int main()
{
	int a = 1;
	printf("%dn", a++);
	printf("%dn", a);
	printf("%dn", ++a);
	printf("%dn", a);
	return 0;
}

前置是前++后使用，后置是先使用后++，- -也是一样。
代码运行结果是：

至于强制类型转换：

double a = 1.0;
int b = (int)a;

正常来说double类型储存到int类型的会丢失精度，编译器也会报警告，我们这时就要用强制类型转换，把a强制类型转换成int类型然后储存进a中。

5.2 sizeof 和 数组

我们来看一下这段代码：

#include 
void test1(int arr[])
{
	printf("%dn", sizeof(arr));//(2)
}
void test2(char ch[])
{
	printf("%dn", sizeof(ch));//(4)
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%dn", sizeof(arr));//(1)
	printf("%dn", sizeof(ch));//(3)
	test1(arr);
	test2(ch);
	return 0;
}

问：
（1）、（3）两个地方分别输出多少？
（2）、（4）两个地方分别输出多少？
（这里用的是32位平台）
我们看一下代码运行的结果：

（1）和（3）很容易理解，（2）和（4）是什么情况？
我们知道，数组传参传的是首元素地址，那么函数中的sizeof算的就是首元素地址的长度，不同数据类型的地址的长度在32位平台下是4个字节，64位平台下是8个字节。

6. 关系操作符

也可以是双目操作符

>
>=
<
<=
!=   //用于测试“不相等”
==   //用于测试“相等”

这些关系运算符比较简单，没什么可说的，但是我们要注意一些运算符使用时候的陷阱。
例如：在编程的过程中== 和=不小心写错，导致的错误。

7. 逻辑操作符

&&     //逻辑与
||     //逻辑或

参考代码如下：

#include 
int main()
{
	int a = 1;
	int b = 1;
	int c = 0;
	int d = 0;
	if (a && b)
	{
		printf("Qn");
	}
	if (a && c)
	{
		printf("Wn");
	}
	if (c && d)
	{
		printf("En");
	}
	if (a || b)
	{
		printf("Rn");

	}
	if (a || c)
	{
		printf("Tn");
	}
	if (c || d)
	{
		printf("Yn");
	}
	return 0;
}

输出结果：

逻辑与是两边的操作数都为真才能通过，逻辑与是两边的操作数有一个为真就会通过。
区分逻辑与和按位与
区分逻辑或和按位或

1&2----->0
1&&2---->1
1|2----->3
1||2---->1

逻辑与和或的特点：
我们来看下面的代码：

#include 
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
	printf("n");
	i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ || ++b || d++;
	printf("a = %dnb = %dnc = %dnd = %dn", a, b, c, d);
	return 0;
}
//程序输出的结果是什么？

代码运行结果如下：

逻辑与：
如果有一个条件未达成，整个条件就是假，也就是说:
a++ && ++b这个表达式为假，那么后面的表达式也一定为假。
所以也就导致了只有a++，其他的表达式并没有进行。
逻辑或：
如果一个条件达成后面的条件就不会在进行了，因为只要有一个成功，整个表达式就为真，但是这里第一个条件为假，第二个为真，整个表达式为真，那么后面的表达式也一定为真。
结果就是只有a++和++b执行。

8. 条件操作符

这个也被称为三目操作符。
exp1 ? exp2 : exp3
这个的意思是，先判断exp1，如果exp1表达式为真，那么结果就是exp2，如果为假结果就是exp3.
我们做一个练习：

#include 
int main()
{
	int a;
	int b;
	scanf("%d", &a);
	if (a > 5)
		b = 3;
	else
		b = -3;
	printf("%d", b);
	return 0;
}

上面这段代码转换成条件表达式，是什么样？

#include 
int main()
{
	int a;
	scanf("%d", &a);
	printf("%d", (a > 5) ? (3) : (-3));
	return 0;
}

这就是条件操作符的使用方法。

9. 逗号表达式

exp1, exp2, exp3, …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
我们这里用代码举例：

//代码1
int a = 1;
int b = 2;
int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
//c是多少？
//代码2
if (a = b + 1, c = a / 2, d > 0)
//代码3 a = get_val();
    count_val(a);
while (a > 0)
{
    //业务处理
    a = get_val();
    count_val(a);
}
//如果使用逗号表达式，改写：
while (a = get_val(), count_val(a), a > 0) 
{
    ;//业务处理
}

代码1：第一个表达式为a>b，当然这个式子是不成立的，但是我们并不用管它，因为它并不影响后面的结果，第二个表达式是a=12，第三个表达式是a=12，第四个表达式是b=13。所以c就是13。
代码2：最后一个表达式才是具有意义的。
代码3：这个循环可以改成下面那段代码。

10. 下标引用、函数调用和结构成员 10.1 [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值
这个之前我们用过好多次了：

int arr[10];//创建数组
arr[9] = 10;//实用下标引用操作符。
[ ]的两个操作数是arr和9。

10.2 ( ) 函数调用操作符

接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
这个操作符我们也是非常的熟悉了：

#include 
void test1()
{
	printf("hehen");
}
void test2(const char* str)
{
	printf("%sn", str);
}
int main()
{
	test1();//实用（）作为函数调用操作符。
	test2("hello lol.");//实用（）作为函数调用操作符。
	return 0;
}

代码运行如下：

10.3 访问一个结构的成员

. 结构体.成员名
-> 结构体指针->成员名

我们还是用一段代码举例：

#include 
struct Stu
{
	char name[10];
	int age;
	char sex[5];
	double score;
};
void set_age1(struct Stu stu) 
{
	stu.age = 18;
}
void set_age2(struct Stu* pStu) 
{
	pStu->age = 18;//结构成员访问
}
int main()
{
	struct Stu stu;
	struct Stu* pStu = &stu;//结构成员访问

	stu.age = 20;//结构成员访问
	printf("%dn", stu.age);
	set_age1(stu);
	printf("%dn", stu.age);
	pStu->age = 20;//结构成员访问
	printf("%dn", pStu->age);
	set_age2(pStu);
	printf("%dn", pStu->age);
	return 0;
}

代码的运行结果：

至于为什么第二个结果为什么是20不是18，因为我们之前说过，set_age1这个函数里面的参数只是一份临时拷贝（如果不懂可以去看看我的函数栈帧的创建与销毁）。
当然这里的结构体指针的访问也可以这么表达：

printf(“%dn”, (*pStu).age);

11. 表达式求值

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

11.1 隐式类型转换

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

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

举个例子：

#include 
int main()
{
	char a = 2;
	char b = 127;
	char c = a + b;
	printf("%d", c);
	return 0;
}

我们都清楚，其实字符类型也属于整形，因为储存的是ASCII码值。
但是数据类型char只有个8个比特位，所以我们的结果有点 ‘ 异常 ’ ：

我们来分析一下这是为什么：
我们都知道，一个整型是4个字节，一个字节是8个比特位，字符类型是1个字节，8个比特位。

这是我们初始化的时候的内部储存空间。
但是我们计算的时候需要整型提升，关于整型提升是这样的：

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

所以我们的提升是这样的过程：

c变成这样之后，我们又要存入char类型的变量c，所以又会变成8个比特位的内存。也就是说char c里面是这样的：

8个比特位只能容纳这些，最后用%d打印，又要整型提升：

11111111111111111111111110000001 补码
11111111111111111111111110000000 反码
10000000000000000000000001111111 原码

很明显，打印的结果是用原码来算的。
c = -127
整型提升的例子

//实例1
#include 
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;
}

实例1中的a,b要进行整形提升,但是c不需要整形提升。
a,b整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表达式 c==0xb6000000 的结果是真。
所程序输出的结果是:

c

//实例2
#include 
int main()
{
	char c = 1;
	printf("%un", sizeof(c));
	printf("%un", sizeof(+c));
	printf("%un", sizeof(-c));
	return 0;
}

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

11.2 算术转换

如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
long double
double
float
unsigned long int
long int
unsigned int
int
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
比如说如果一个int类型和double进行运算，那么int一定会转换成double类型，然后再进行运算。
注意：但是算术转换要合理，要不然会有一些潜在的问题。

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

如果打印整型变量num，结果就是3。

11.3 操作符的属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。
   两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
   操作符优先级
   N/A是不讨论结合性。
   L-R是从左到右
   R-L是从右到左

最上面的优先度最高，越往下越低。

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
（）	聚组	（表达式）	与表达式同	N/A	否
（）	函数调用	rexp（rexp，…,rexp）	rexp	L-R	否
[ ]	下标引用	rexp[rexp]	lexp	L-R	否
.	访问结构成员	lexp.member_name	lexp	L-R	否
->	访问结构指针成员	rexp->member_name	lexp	L-R	否
++	后缀自增	lexp ++	rexp	L-R	否
- -	后缀自减	lexp –	rexp	L-R	否
！	逻辑反	! rexp	rexp	R-L	否
~	按位取反	~ rexp	rexp	R-L	否
+	单目，表示正值	+rexp	rexp	R-L	否
-	单目，表示负值	-rexp	rexp	R-L	否
++	前缀自增	++ lexp	rexp	R-L	否
- -	前缀自减	- - lexp	rexp	R-L	否
*	间接访问	*rexp	lexp	R-L	否
&	取地址	&lexp	rexp	R-L	否
sizeof	取其长度，以字节表示	sizeof rexp sizeof(类型）	rexp	R-L	否
（类型）	类型转换	（类型) rexp	rexp	R-L	否
*	乘法	rexp * rexp	rexp	L-R	否
/	除法	rexp / rexp	rexp	L-R	否
%	整数取余	rexp % rexp	rexp	L-R	否
+	加法	rexp + rexp	rexp	L-R	否
-	减法	rexp - rexp	rexp	L-R	否
<<	左移位	rexp << rexp	rexp	L-R	否
>>	右移位	rexp >> rexp	rexp	L-R	否
>	大于	rexp > rexp	rexp	L-R	否
>=	大于等于	rexp >= rexp	rexp	L-R	否
<	小于	rexp < rexp	rexp	L-R	否
<=	小于等于	rexp <= rexp	rexp	L-R	否
==	等于	rexp == rexp	rexp	L-R	否
！=	不等于	rexp != rexp	rexp	L-R	否
&	位与	rexp & rexp	rexp	L-R	否
^	位异或	rexp ^ rexp	rexp	L-R	否
|	位或	rexp | rexp	rexp	L-R	否
&&	逻辑与	rexp && rexp	rexp	L-R	是
||	逻辑或	rexp || rexp	rexp	L-R	是
? :	条件操作符	rexp ? rexp : rexp	rexp	N/A	是
=	赋值	lexp = rexp	rexp	R-L	否
+=	以…加	lexp += rexp	rexp	R-L	否
-=	以…减	lexp -= rexp	rexp	R-L	否
*=	以…乘	lexp *= rexp	rexp	R-L	否
/=	以…除	lexp /= rexp	rexp	R-L	否
%=	以…取模	lexp %= rexp	rexp	R-L	否
<<=	以…左移	rexp<<=rexp	rexp	R-L	否
>>=	以…右移	rexp>>=rexp	rexp	R-L	否
&=	以…与	rexp&=rexp	rexp	R-L	否
^=	以…异或	rexp^=rexp	rexp	R-L	否
|=	以…或	rexp|=rexp	rexp	R-L	否
，	逗号	rexp，rexp	rexp	L-R	是

一些问题表达式
这些问题表达式就和先有鸡还是先有蛋一样坑人！

//表达式的求值部分由操作符的优先级决定。
//表达式1 
a*b + c*d + e*f;
//表达式2 
c + --c;
//代码3-非法表达式
int main()
{
 	int i = 10;
 	i = i-- - --i * ( i = -3 ) * i++ + ++i;
 	printf("i = %dn", i);
 	return 0; 
 }

代码1：在计算的时候，由于*比+的优先级高，只能保证，*的计算是比+早，但是优先级并不
能决定第三个*比第一个+早执行。
所以表达式的计算机顺序就可能是：

ab
cd
ab + cd
ef
ab + cd + ef
或者：
ab
cd
ef
ab + cd
ab + cd + ef

代码2：在计算的时候，同上，操作符的优先级只能决定自减–的运算在+的运算的前面，但是我们并没有办法得知，+操作符的左操作数的获取在右操作数之前还是之后求值，所以结果是不可预测的，是有歧义的。
代码3：表达式3在不同编译器中测试结果：非法表达式程序的结果

值	编译器
—128	Tandy 6000 Xenix 3.2
—95	Think C 5.02(Macintosh)
—86	IBM PowerPC AIX 3.2.5
—85	Sun Sparc cc(K&C编译器)
—63	gcc，HP_UX 9.0，Power C 2.0.0
4	Sun Sparc acc(K&C编译器)
21	Turbo C/C++ 4.5
22	FreeBSD 2.1 R
30	Dec Alpha OSF1 2.0
36	Dec VAX/VMS
42	Microsoft C 5.1

由此可见这种代码多么的坑爹，我们写入代码一定要避免这种情况，多写几行没问题，如果为了省几行从而导致这种情况发生，那真是得不偿失。

//代码4
int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	answer = fun() - fun() * fun();
	printf("%dn", answer);//输出多少？
	return 0;
}

这个代码有没有实际的问题？
有问题！
虽然在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() - fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法，
再算减法。
函数的调用先后顺序无法通过操作符的优先级确定。

//代码5
#include 
int main()
{
	int i = 1;
	int ret = (++i) + (++i) + (++i);
	printf("%dn", ret);
	printf("%dn", i);
	return 0;
}
//尝试在linux 环境gcc编译器，VS2013环境下都执行，看结果。

VS2022：

linux：

看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码.就可以分析清楚。
这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。
总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。

结束语

家人们请点个赞，路过的大佬指点错误和不足！！！