C语言学习之路--操作符篇，从知识到实战

一、前言

• 本人是一名小白，这一篇是记录我C语言学习中的操作符的所学所得，仅为简单的认识下C语言中的各个知识。

二、操作符分类

算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员

三、算术操作符

+ - * / %

1. 除了 % 操作符只作用于整数之外，其他的几个操作符可以作用于整数和浮点数。
2. 对于 / 操作符如果两个操作数都为整数，执行整数除法，结果为商。而只要有浮点数执行的就是浮点数除法，从而得到小数的结果。

#include <stdio.h>

int main()
{
	int a = 5;
	int b = 2;
	double c = 2.0;
	//只得到整数结果（商）
	printf("%d\n", a / b);
	//除法想得到小数的结果，必须保证除数和被除数至少有一个是浮点数
	printf("%.1f\n", a / c);//2.5
	return 0;
}

运行结果

4. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。

四、移位操作符

<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。

• 移动的是二进制位
• 二进制位的表示，进制详解见博客：进制详解
• 整数，在c语言中可以存放到int类型的变量中，int类型是4个字节，32bit，在内存中存储的是整数的二进制的补码
• 移位操作符，移动的是存储在内存中的补码

1、左移操作符

• 左边丢弃、右边补0，扩大二倍
• 举例

1. 正整数

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 4;
	//0000 0000 0000 0000 0000 0000 0000 0100，a的补码
	int b = a << 1;//把a向左移动一位赋给b，但a不发生变化
	//右边添0，左边抛弃
	//0000 0000 0000 0000 0000 0000 0000 1000，b的补码
	printf("a=%d b=%d\n", a, b);
	return 0;
}

运算结果

2. 负整数

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = -4;
	//1111 1111 1111 1111 1111 1111 1111 1100，a的补码
	int b = a << 1;//把a向左移动一位赋给b，但a不发生变化
	//右边添0，左边抛弃
	//1111 1111 1111 1111 1111 1111 1111 1000，b的补码,-8
	printf("a=%d b=%d\n", a, b);
	return 0;
}

运算结果

2、右移操作符

首先右移运算分两种：

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

• 注意：是哪种移动方式，编译器并没有明确规定，取决于编译器。但大部分是算数移位。
• 举例：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = -4;
	//1111 1111 1111 1111 1111 1111 1111 1100，a的补码
	int b = a >> 1;//把a向右移动一位赋给b，但a不发生变化
	//左边用原该值的符号位填充，右边丢弃
	//1111 1111 1111 1111 1111 1111 1111 1110，b的补码,-2
	printf("a=%d b=%d\n", a, b);
	return 0;
}

运行结果

警告⚠ ：
对于移位运算符，不要移动负数位，这个是标准未定义的。

int num = 10;
num>>-1;//error

五、位操作符

位操作符有：

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

• 按照二进制位，详见博客：位操作符

举例

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 3;
	//a的原码，反码，补码相同
	//0000 0000 0000 0000 0000 0000 0000 0011
	int b = -5;
	//b的原码 1000 0000 0000 0000 0000 0000 0000 0101
	//b的反码 1111 1111 1111 1111 1111 1111 1111 1010
	//b的补码 1111 1111 1111 1111 1111 1111 1111 1011
	int c = a & b;
	//0000 0000 0000 0000 0000 0000 0000 0011
	//1111 1111 1111 1111 1111 1111 1111 1011
	//0000 0000 0000 0000 0000 0000 0000 0011 c的补码，3
	int d = a | b;
	//0000 0000 0000 0000 0000 0000 0000 0011
    //1111 1111 1111 1111 1111 1111 1111 1011
	//1111 1111 1111 1111 1111 1111 1111 1011 d的补码，-5
	int e = a ^ b;
	//0000 0000 0000 0000 0000 0000 0000 0011
    //1111 1111 1111 1111 1111 1111 1111 1011
	//1111 1111 1111 1111 1111 1111 1111 1000 e的补码，-8
	printf("c=%d d=%d e=%d\n", c, d, e);
	return 0;
}

运算结果

拓展

• X^Y^Y = X
• 0^X = X
• X ^ X = 0
• 异或支持交换律
  举例：

1、不能创建临时变量（第三个变量），实现两个数的交换。

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

//数学方法
void ex_suanshu(int a, int b)
{
	a = a + b;
	b = a - b;//a+b-b=a
	a = a - b;//a+b-a=b
	printf("a=%d b=%d\n", a, b);
}

//异或法
void ex_yihuo(int a, int b)
{
	a = a ^ b;
	b = a ^ b;//a^b^b=a
	a = a ^ b;//a^b^a=b
	printf("a=%d b=%d\n", a, b);
}

int main()
{
	int a = 3;
	int b = 5;
	ex_suanshu(a, b);//可能会溢出，a+b的和可能超出int范围
	ex_yihuo(a, b);
	return 0;
}

运算结果

2、编写代码实现：求一个整数存储在内存中的二进制中1的个数。

• 此处只给出一个常规方法

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int i = 5;
	//i的补码 0000 0000 0000 0000 0000 0000 0000 0101
	int m = 1;
	//m的补码 0000 0000 0000 0000 0000 0000 0000 0001
	int j = 0;
	int count = 0;
	for (j = 0; j < 32; j++)
	{
		if ((m & i >> j) == 1)
		{
			count++;
		}
	}
	printf("%d\n", count);
	return 0;
}

运行结果

六、赋值操作符

• 赋值操作符是一个很棒的操作符，他可以让你得到一个你之前不满意的值。也就是你可以给自己重新赋
  值。

赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//连续赋值,y+1先赋给x，x在赋给a，不利于调试
这样的代码感觉怎么样？
那同样的语义，你看看：
x = y+1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。

复合赋值符
+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

int x = 10;
x = x+10;
x += 10;//复合赋值
//其他运算符一样的道理。这样写更加简洁。

七、单目操作符

• 只针对一个对象

1、简介

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

1、！

#define  _CRT_SECURE_NO_WARNINGS 1
# include <stdio.h>

int main()
{
	//“!”介绍，当某个条件为假，我还想执行，就可以用！
	//举例
	int flag = 0;
	if (!(flag != 0))
	{
		printf("呵呵\n");
	}
	return 0;
}

运行结果

2、&和*

• 一个字节对应一个地址

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 10;//占用四个字节
	printf("%d\n", sizeof(a));//打印a所占空间，单位是字节
	char b = 0;//占用一个字节
	printf("%d\n", sizeof(b));//打印b所占空间

	printf("%p\n", &a);//打印a的地址
	printf("%p\n", &b);//打印c的地址

	int* pa = &a;//&a就是取a的地址，pa是指针变量，*告诉我们pa是指针变量，int是告诉我们pa指向的a是int类型
	*pa = 20;//* - 是解引用操作符，此时*pa就是a
	printf("%d\n", a);//看a是否改变

	int arr[10] = { 0 };
	&arr;//取数组的地址

	//野指针 - 问题，程序会崩
	*(int*)0x00001123 = 100;

	return 0;
}

运行结果

3、sizeof

• 关于sizeof其实我们之前已经见过了，可以求变量（类型）所占空间的大小。（单位：字节）

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 0;
	int* pa;
	int arr[10] = { 0 };
	//sizeof()的格式化输出用%zu，只是识别所言计算变量的类型，并不访问，因此数组越界也并不会程序崩溃
	printf("%zu\n", sizeof(a));
	printf("%zu\n", sizeof(pa));
	printf("%zu\n", sizeof(arr));
	printf("%zu\n", sizeof(arr[10]));

	printf("%zu\n", sizeof a);//当sizeof后面是变量时，（）可以省略，但类型的话则不行，从而也证明其是操作符而不是函数
	//printf("%zu\n", sizeof int);//这种写法是错误的

	return 0;
}

运行结果

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	short s = 2;
	int a = 4;
	printf("%zu\n", sizeof(s = a + 5));//2
	//首先，对于式子s = a + 5，s是short类型，而a+5是int类型，是要进行截断（去掉两个字节）的
	//sizeof（表达式）中，表达式是不会进行计算的，只是推理出类型
	//表达式不会计算的原因：我们写代码执行程序时，是要从test.c源文件->编译->链接->test.exe，而sizeof在编译期间就执行完了，运行代码时候自然便没有它
	printf("%d\n", s);//2


	//下面介绍一下截断
	s = a + 5;
	//a 0000 0000 0000 0000 0000 0000 0000 0100
	//5 0000 0000 0000 0000 0000 0000 0000 0101
	//a+5 0000 0000 0000 0000 0000 0000 0000 1001  9
	//截断，取a+5的后两个字节 0000 0000 0000 1001 并将其放到s里面去
	//s 0000 0000 0000 1001
	printf("%d\n", s);

	return 0;
}

2、sizeof和数组

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

void test1(int arr[])
{
	printf("%d\n", sizeof(arr));//(2)4
}

void test2(char ch[])
{
	printf("%d\n", sizeof(ch));//(4)4
}

int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));//(1)40
	printf("%d\n", sizeof(ch));//(3)10
	test1(arr);
	test2(ch);

	return 0;
}

运行结果

详见博客：C语言学习之路–获取函数参数的数组的元素个数

3、+ +和- -运算符

• 前置，先增/减再使用
• 后置，先使用再增/减

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 10;
	int x = ++a;
	//先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。
	int y = --a;
	//先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10;

	int b = 10;
	int z = b++;
	//先对b先使用，再增加，这样z的值是10；之后b变成11；
	int w = b--;
	//先对b先使用，再自减，这样w的值是11；之后b变成10；

	return 0;
}

4、~

• 二进制按位取反，符号位也进行操作
• 详见博客：非运算

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 10;
	int n = 0;
	scanf("%d", &n);
	//把a的第n位置为1
	a = a | (1 << (n-1));
	printf("a=%d\n", a);

	//把a的第n位置为0
	a = a & ~(1 << (n - 1));
	printf("a=%d\n", a);

	//00000000000000000000000000001010
	//00000000000000000000000000010000
	//1<<2;
	//00000000000000000000000000011010
	//11111111111111111111111111101111
	//00000000000000000000000000010000
	//00000000000000000000000000001010
	return 0;
}

5、（）

• 强制类型转换

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = (int)3.14;//只保留整数部分
	printf("%d\n", a);

	return 0;
}

运算结果

八、关系操作符

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

注意：在编程的过程中== 和=不小心写错，导致的错误。

• 并不是所有对象都能这样比，比如说数组，字符串，结构体
• ==不能比较两个字符串的内容，实际上比的是2个字符串的首字符的地址

九、 逻辑操作符

逻辑操作符有哪些：

&& 逻辑与
|| 逻辑或

• 区分逻辑与和按位与
• 区分逻辑或和按位或

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	//这里涉及到一个断路问题，对于&&当判断到一个表达式（会执行）为假时，后续的便不再执行，同理对于||当判断到一个表达式为真（会执行）时，后续的便不再执行
	//i = a++||++b||d++;
	printf("a = %d\nb = %d\nc = %d\nd = %d\n", a, b, c, d);
	printf("%d\n", i);//&&与||，判断为真时，i为1，否则为0

	return 0;
}

运行结果

十、条件操作符

• 也称为三目操作符（有三个操作数）

exp1 ? exp2 : exp3
当exp1为真，exp2执行为整个表达式的结果，exp3不执行
当exp1为假，exp3执行为整个表达式的结果，exp2不执行

举例：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 3;
	int b = 2;
	if (a > 5)
	{
		b = 3;
	}
	else
	{
		b = 0;
	}

	b = (a > 5 ? 3 : 0);//与else语句逻辑一样

	//求两个数最大值
	int m = (a > b ? a : b);

	return 0;
}

十一、逗号表达式

exp1,exp2,…,expn

• 逗号表达式，就是用逗号隔开的多个表达式。
• 逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);//逗号表达式
	//从左向右依次执行
	//首先，a>b为假，这个式子便是0
	//a = b + 10，a为12
	//a
	//b = a + 1，b=13
	//最后，赋值给c
	printf("%d\n", c);//13

	int d = 1;
	if (a = b + 1, c = a / 2, d > 0)//从左向右依次计算，最后判断d>0
	{

	}

	a = get_val();
	count_val(a);
	while (a > 0)
	{ 
		//业务处理
		a = get_val();
		count_val(a);
	}
	//如果使用逗号表达式，改写：
	while (a = get_val(), count_val(a), a > 0)//从左向右依次执行，最后判断a>0
	{
		//业务处理
	}


	return 0;
}

十二、下标引用、函数调用和结构成员

1、下标引用操作符 [ ]

• 不是定义数组的[ ]
• 操作数：一个数组名 + 一个索引值

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

2、（）函数调用操作符

• 接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。

#include <stdio.h>
 void test1()
 {
 printf("hehe\n");
 }
 void test2(const char *str)
 {
 printf("%s\n", str);
 }
 int main()
 {
 test1();            //实用（）作为函数调用操作符。
 test2("hello bit.");//实用（）作为函数调用操作符。
 return 0;
 }

3、访问一个结构的成员

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

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

//书：书名，价格

struct Book
{
	char name[10];
	int price;

};

int main()
{
	struct Book sb = { "一",55 };

	printf("%d\n", sb.price);//结构体变量.结构体成员名

	struct Book* ps = &sb;
	printf("%d\n", (*ps).price);///*ps必须加括号，因为.的优先级高于* 

	printf("%d\n", ps->price);//结构体指针->结构体成员名


	return 0;
}

十三、表达式求值

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

1、隐式类型转换

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

//实例1
char a,b,c;
...
a = b + c;

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

1、整型提升的意义

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

2、如何进行整体提升呢？

• 整形提升是按照变量的数据类型的符号位来提升的
• 无符号整形提升，高位补0
  举例：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	char a = 5;
	//5用二进制为0000 0000 0000 0000 0000 0000 0000 0101
	//由于是char类型，进行截断
	//0000 0101  -   a
	char b = 126;
	//126用二进制为0000 0000 0000 0000 0000 0000 0111 1110
	//进行截断
	//0111 1110  -   b
	char c = a + b;
	//a,b整型提升
	//a - 0000 0000 0000 0000 0000 0000 0000 0101
	//b - 0000 0000 0000 0000 0000 0000 0111 1110
	//c - 0000 0000 0000 0000 0000 0000 1000 0011
	//截断 c - 1000 0011
	printf("%d\n", c);
	//%d 十进制的方式打印有符号数
	//c整型提升
	//1111 1111 1111 1111 1111 1111 1000 0011 - 补码
	//1111 1111 1111 1111 1111 1111 1000 0010 - 反码
	//1000 0000 0000 0000 0000 0000 0111 1101 - 原码，-125
	//c也就是-125
	return 0;
}

运行结果

2.

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

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;
}

运行结果

• 为什么会这样呢？
• 原因：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© ,就是1个字节.

2、算术转换

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

#define  _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int main()
{
	float f = 3.14;
	int sum = f;
	printf("%f", sum);

	return 0;
}

运行结果：

3、操作符的属性

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

1. 操作符的优先级
2. 操作符的结合性
3. 是否控制求值顺序。

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

操作符优先级见下图（从上到下，优先级从高到低）

操作符	描述	用法示例	结果类型	结核性	是否控制求值顺序
()	聚组	（表达式）	与表达式相同	N/A	否
（）	函数调用	rexp(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),siaeof(类型（int等））	rexp	R-L	否
（类型）	类型转换	（类型）rexp	rexp	R-L	否
*	乘法	rexp * 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	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	否
&	位与	rexo&rexp	rexp	L-R	否
^	位异或	rexp^rexp	rexp	L-R	否
I	位或	rexp I rexp	rexp	L-R	否
&&	逻辑与	rexp&&rexp	rexp	L-R	是
II	逻辑或	rexp II 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	否
<<=	以…左移	lexp <<= rexp	rexp	R-L	否
>>=	以…右移	lexp >>= rexp	rexp	R-L	否
&=	以…与	lexp &= rexp	rexp	rexp	R-L
^=	以…异或	lexp ^= rexp	rexp	R-L	否
I=	以…或	lexp I= rexp	rexp	R-L	否
，	逗号	rexp,rexp	rexp	L-R	是

一些问题表达式

• 我们清楚，表达式的求值部分是由操作符的优先级决定的，但在一些复杂表达式中，就会出现多种可能，此时便是由我们所用的编译器决定

表达式1

a*b+c*d+e*f

• 表达式1在计算的时候，由于 * 比 + 的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个比第一个+早执行
  所以表达式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+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;
}

• 此表达式为非法表达式，在不同的编译器所得结果不同。

表达式4

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

int main()
{
      int answer;
      answer = fun() - fun() * fun();
      printf("%d\n",answer);
      retuen 0;
}

这个代码有问题吗？
有问题！
虽然在大多数编译器求得的结果是相同的。
但是上述代码

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

中我们只能通过操作符的优先级的得知：先算乘法，再算减法。
函数调用的先后顺序无法通过优先级确定。

表达式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编译器和用VS编译器所得结果不同。
  原因：这段代码第一个+在执行的时候，第三个++是否执行，这个是不确定的，
  总结： 我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。