【C语言】初级第5节——操作符详解

1. 操作符分类

算术操作符

移位操作符

位操作符

赋值操作符

单目操作符

关系操作符

逻辑操作符

条件操作符

逗号表达式

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

2. 算术操作符

运算符	意义	说明
+	加法
-	减法	如果减去一个负数，则-左右必须加空格
*	乘法
/	除法	两个整数相除结果是整数（小数部分被截取）；两个数中有一个是浮点数，其结果就是浮点数
%	取模	求整数除法的余数，其正负取决于被除数

1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。

2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。

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

这五种运算符的运算优先级为*=/=%>+=-，即 *、/、% 具有相同的优先级，它们的级别大于 + 和 -，+ 和 - 具有相同的优先级；优先级相同时按从左向右的顺序运算。使用括号可以打破上述优先级规则，括号具有最高的优先级。

在 C语言中的加、减、乘与通常数学运算中的定义完全相同，几乎可以用于所有数据类型；而除法运算在 C语言中较为特殊，详述如下。

1) 除法运算

C语言中使用/对整型数据进行除运算时，结果的小数部分将被截掉，其被看成是“整除运算”；但若除数或被除数有一个是带小数位的实数，则被看成是“实数除法”，结果中的小数位将进行四舍五入处理。例如：

int Average = 8 / 3;               //运行后变量 Average 的值为 2
float Average = 8 / 3;             //运行后变量 Average 的值为 2.000000
float Average = 8 / 3.0;           //运行后变量 Average 的值为 2.666667
float Average = 8.0 / 3;           //运行后变量 Average 的值为 2.666667
float Average = 8.0 / 3.0;         //运行后变量 Average 的值为 2.666667

另外，编写代码时，若除数或被除数有一个是带小数位的实数，有的编译器默认此数据类型是double，如果定义的是float类型，可能会有如下warning：

warning C4305: “初始化”: 从“double”到“float”截断

解决办法：

1.数字的后面加f标识转换为float数据类型，如：

float  a = 8.0f / 3.0f;

2.把定义的float函数和参数改成double，如：

double  a = 8.0 / 3.0;

2) 求模运算

用%求除法余数的运算在编程中称为求模。求模运算只能用于整型数据。例如：

int a = 8 % 3;                //运行后变量 a 的值为 2，即 8 除以 3 的余数 2

3) 字符型数据的算术运算

在 C语言中，字符型的数据也可以参加算术运算。前面讲过，字符在计算机中也是以数字的形式存在的，每一个字符都对应于一个数字（见 ASCII 标准字符代码表），因而字符参加算术运算实际上就是对应字符的十进制字符代码参加运算。例如：

int Su = 'A' + 'B' + 20;     //运行后变量 Su 的值为 151

在“ASCII 标准字符代码表”中，字符 ‘A’ 的十进制字符代码是 65，字符 ‘B’ 的十进制字符代码是 66，因而上述语句的计算结果相当于以下语句：

int Su = 65 + 66 + 20; 

3. 移位操作符

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

3.1 左移操作符

二进制左移运算符，将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。

移位规则：

左边抛弃、右边补0

3.2 右移操作符

二进制右移运算符，将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。

移位规则：

首先右移运算分两种：

1. 逻辑移位

   左边用0填充，右边丢弃

2. 算术移位

   左边用原该值的符号位填充，右边丢弃

补充说明：

• 数据在内存中始终是以二进制形式存放的，数值是以补码表示的。

整数的二进制表示形式其实有三种：

• 原码：直接根据数值写出的二进制序列就是原码
• 反码：反码的符号位不变，其他位按位取反就是反码
• 补码：反码+1，就是补码

对于正整数来说，它的原码、反码、补码相同

例：负数 -1

​ 原码：10000000000000000000000000000001

​ 反码：11111111111111111111111111111110

​ 补码：11111111111111111111111111111111

警告⚠ ：

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

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

4. 位操作符

位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：

p	q	p & q	p|q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

下表显示了 C 语言支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符	描述	实例
&	按位与操作，按二进制位进行"与"运算。运算规则： 0&0=0; 0&1=0; 1&0=0; 1&1=1;	(A & B) 将得到 12，即为 0000 1100
|	按位或运算符，按二进制位进行"或"运算。运算规则： 0|0=0; 0|1=1; 1|0=1; 1|1=1;	(A |B) 将得到 61，即为 0011 1101
^	异或运算符，按二进制位进行"异或"运算。运算规则： 0^0=0; 0^1=1; 1^0=1; 1^1=0;	(A ^ B) 将得到 49，即为 0011 0001
~	取反运算符，按二进制位进行"取反"运算。运算规则： ~1=-2; ~0=-1;	(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。

• 注：他们的操作数必须是整数。

练习一下：

#include <stdio.h>
int main()
{
	int num1 = 1;//1的二进制为00000000000000000000000000000001
	int num2 = 2;//2的二进制为00000000000000000000000000000010
	int a = num1 & num2;//1和2进行按位与操作后结果为00000000000000000000000000000000
	int b = num1 | num2;//1和2进行按位或操作后结果为00000000000000000000000000000011
	int c = num1 ^ num2;//1和2进行按位异或操作后结果为00000000000000000000000000000011
	printf("a=%d\n", a);
	printf("b=%d\n", b);
	printf("c=%d\n", c);
	return 0;
}

输出结果为：

a=0
b=3
c=3

一道变态的面试题：

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

方法1：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	a = a + b;
	b = a - b;
	a = a - b;
	printf("a = %d b = %d\n", a, b);
	return 0;
}

但是这种方法有缺陷，数值太大会溢出。

方法2：利用异或 ^ 来交换两个数的值

#include<stdio.h>
int main()
{
    unsigned int a = 60;            //0011 1100
    unsigned int b = 13;            //0000 1101
    printf("a=%d,b=%d", a, b);      //输出a，b的值
    printf("\n");
    a = a ^ b;                      //a=a^b=0011 0001
    b = a ^ b;                      //b=a^b=0011 1100
    a = a ^ b;                      //a=a^b=0000 1101
    printf("a=%d,b=%d", a, b);      //输出a，b的值
    return 0;
}

运行结果：

a=60，b=13；
a=13，b=60;

仅用一行代码实现的方法:

a^=b^=a^=b;

这种利用位运算的交换方法只适用于整型变量，不能用于浮点型变量!

• 两个相同的数字异或后的结果是0，0和任何数字异或后还是这个数字本身；
• 两个数异或后的结果再与其中一个数异或可以得到另一个数。

这种方法不会溢出。

练习：

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

参考代码：

//方法1
#include <stdio.h>
int main()
{
	int num = 10;
	int count = 0;//计数
	while (num)
	{
		if (num % 2 == 1)
			count++;
		num = num / 2;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}
//思考这样的实现方式有没有问题？

//方法2：
#include <stdio.h>
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	for (i = 0; i < 32; i++)
	{
		if (num & (1 << i))
			count++;
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}
//思考还能不能更加优化，这里必须循环32次的。

//方法3：
#include <stdio.h>
int main()
{
	int num = -1;
	int i = 0;
	int count = 0;//计数
	while (num)
	{
		count++;
		num = num & (num - 1);
	}
	printf("二进制中1的个数 = %d\n", count);
	return 0;
}
//这种方式是不是很好？达到了优化的效果，但是难以想到。

5. 赋值操作符

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

int weight = 120;//体重
weight = 89;//不满意就赋值
double salary = 10000.0;
salary = 20000.0;//使用赋值操作符赋值。
赋值操作符可以连续使用，比如：
int a = 10;
int x = 0;
int y = 20; 
a = x = y + 1;//连续赋值
这样的代码感觉怎么样？
那同样的语义，你看看：
x = y + 1;
a = x;
这样的写法是不是更加清晰爽朗而且易于调试。

下表列出了 C 语言支持的赋值运算符：

运算符	描述	实例
=	简单的赋值运算符，把右边操作数的值赋给左边操作数	C = A + B 将把 A + B 的值赋给 C
+=	加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数	C += A 相当于 C = C + A
-=	减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数	C -= A 相当于 C = C - A
*=	乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数	C *= A 相当于 C = C * A
/=	除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数	C /= A 相当于 C = C / A
%=	求模且赋值运算符，求两个操作数的模赋值给左边操作数	C %= A 相当于 C = C % A
<<=	左移且赋值运算符	C <<= 2 等同于 C = C << 2
>>=	右移且赋值运算符	C >>= 2 等同于 C = C >> 2
&=	按位与且赋值运算符	C &= 2 等同于 C = C & 2
^=	按位异或且赋值运算符	C ^= 2 等同于 C = C ^ 2
|=	按位或且赋值运算符	C |=2等同于 C = C|2

6. 单目操作符

6.1 单目操作符介绍

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

演示代码：

#include <stdio.h>
int main()
{
	int a = -10;
	int* p = NULL;
	printf("%d\n", !2);
	printf("%d\n", !0);
	a = -a;
	p = &a;
	printf("%d\n", sizeof(a));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof a);//这样写行不行？(可以)
	printf("%d\n", sizeof int);//这样写行不行？(不行)
    //sizeof是一个操作符，不是函数
	return 0;
}

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

6.2 sizeof 和 数组

sizeof()作用是返回变量的大小。

#include <stdio.h>
void test1(int arr[])
{
	printf("%d\n", sizeof(arr));
}
void test2(char ch[])
{
	printf("%d\n", sizeof(ch));
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(ch));
	test1(arr);
	test2(ch);
	return 0;
}

运行结果：

40
10
4
4

#include <stdio.h>
int main()
{
	short s = 5;
	int a = 10;
	printf("%d\n", sizeof(s = a + 2));
	printf("%d\n", s);
	return 0;
}

运行结果：

2
5

sizeof括号中放的表达式是不参与运算的！

7.自增和自减操作符

自增运算符++的功能是使变量的值自增 1，自减运算符--的功能是使变量的值自减 1。

自增和自减运算因其表达式中只有一个变量，所以称其为单目运算，它们有以下几种形式：

++i;               //i 的值自增 1 后再参与其它运算
--i;               //i 的值自减 1 后再参与其它运算
i++;               //参与运算后，i 的值再自增 1
i--;               //参与运算后，i 的值再自减 1

示例：

#include <stdio.h>
#include <stdlib.h>
int main( )
{
    int i = 5;                          //i 的初始值为 5
    printf("%d\n",++i);                 //加 1 后输出，输出为 6；此时 i 为 6
    printf("%d\n",--i);                 //减 1 后输出，输出为 5；此时 i 为 5
    printf("%d\n",i++);                 //输出后再加 1，输出为 5；此时 i 为 6
    printf("%d\n",i--);                 //输出后再减 1，输出为 6；此时 i 为 5
    printf("%d\n",-i++);                //输出 -i 后再加 1，输出为 -5；此时 i 为 6
    printf("%d\n",-i--);                //输出 -i 后再减 1，输出为 -6；此时 i 为 5
    system("pause");
    return 0;
}

8. 关系操作符

下表显示了 C 语言支持的所有关系运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：

运算符	描述	实例
==	检查两个操作数的值是否相等，如果相等则条件为真。	(A == B) 为假。
!=	检查两个操作数的值是否相等，如果不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是则条件为真。	(A > B) 为假。
<	检查左操作数的值是否小于右操作数的值，如果是则条件为真。	(A < B) 为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。	(A >= B) 为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。	(A <= B) 为真。

另外，比较两个字符串是否相等，不能使用==，应该使用strcmp。

警告⚠：

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

9. 逻辑操作符

下表显示了 C 语言支持的所有关系逻辑运算符。假设变量 A 的值为 1，变量 B 的值为 0，则：

运算符	描述	实例
&&	称为逻辑与运算符。如果两个操作数都非零，则条件为真。	(A && B) 为假。
||	称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。	(A ||B) 为真。
!	称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。	!(A && B) 为真。

| 和 ||，& 和 && 的区别

我们将 || 和 && 定义为逻辑运算符，而 | 和 & 定义为位运算符。

&& 如果两个操作数都非零，则条件为真；

|| 如果两个操作数中有任意一个非零，则条件为真。

& 按位与操作，按二进制位进行"与"运算。运算规则：（有 0 则为 0）

| 按位或运算符，按二进制位进行"或"运算。运算规则：（有 1 则为 1）

那么，问题来了，在判断语句中，用 | 还是 ||，& 还是 &&？

判断语句中为布尔类型，值只有 true 和 false（如果变量值为 0 就是 false，否则为 true）

举个例子，a=1 b=2
所以 a>0 这个值为true    b>1 这个值为true     b>2 这个值为 false
如 if(a>0&b>1)  我们可以得出 if(true&true)，条件成立（true不为0，所以true&true不为0）
如 if(a>0&&b>1)  我们可以得出 if(true&&true),条件成立（&&两边操作数都非零，所以条件成立）
如 if(b>2&a>0) 我们可以得出 if(false&true)，条件不成立（false为0，false&true为0，条件不成立）
如 if(b>2&&a>0) 我们可以得出 if(false&&a>0)，条件不成立（&&左侧为false，&&运算到此结束，条件不成立）

可以看出 & 和 && 在判断语句中都可以实现“和”这个功能，不过区别在于 & 两边都运算，而 && 先算 && 左侧，若左侧为 false 那么右侧就不运算了。因此从效率上来说，判断语句中推荐使用 &&（换句话就是逻辑运算就老老实实用逻辑运算符，不然它为啥叫逻辑运算符呢？）

而 | 和 || 的比较与上类似，不做赘述。

下面是一道笔试题：

#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);
	return 0;
}

运行结果：

a = 1
b = 2
c = 3
d = 4

10. 条件操作符

条件操作符也被叫做三目操作符。

exp1 ? exp2 : exp3

含义：如果exp1为真 ? 则值为 exp2 : 否则值为 exp3

例子：

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 0;
	b = (a == 1) ? 20 : 30;
	printf("b 的值是 %d\n", b);

	b = (a == 10) ? 20 : 30;
	printf("b 的值是 %d\n", b);
}

运行结果：

b 的值是 30
b 的值是 20

11. 逗号表达式

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) {
	//业务处理
}

12. 下标引用、函数调用和结构成员

1. [ ] 下标引用操作符

操作数：一个数组名 + 一个索引值

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

2. ( ) 函数调用操作符

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

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

3. 访问一个结构的成员

. 结构体.成员名

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

#include <stdio.h>
//创建了一个自定义的类型
struct Book
{
	//结构体的成员（变量）
	char name[20];
	char id[20];
	int price;
};
int main()
{
	struct Book b = { "C语言","C2022410",65 };
	struct Book* pb = &b;
	//结构体指针->成员名
	printf("书名：%s\n", pb->name);
	printf("书号：%s\n", pb->id);
	printf("定价：%d\n", pb->price);

	//printf("书名：%s\n", (*pb).name);
	//printf("书号：%s\n", (*pb).id);
	//printf("定价：%d\n", (*pb).price);

	//结构体变量名.成员名
	//printf("书名：%s\n", b.name);
	//printf("书号：%s\n", b.id);
	//printf("定价：%d\n", b.price);

	return 0;
}

13. 表达式求值

表达式求值的顺序一部分是由操作符的优先级和结合性决定。

同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。

13.1 隐式类型转换

C的整型算术运算总是至少以缺省整型类型的精度来进行的。

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

整型提升的意义：

表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度一般就是int的字节长度，同时也是CPU的通用寄存器的长度。

因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。

通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算。

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

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

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

如何进行整型提升呢？

整型提升是按照变量的数据类型的符号位来提升的

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

例1：

#include <stdio.h>
int main()
{
	char a = 3;
	//转化为二进制00000000000000000000000000000011
	//因为是char类型，所以存入00000011——a
	char b = 127;
	//转化为二进制00000000000000000000000001111111
	//因为是char类型，所以存入01111111——b

	char c = a + b;
    //发现a和b都是char类型的，都没有达到一个int的大小
	//这里就会发生整型提升
	//00000000000000000000000000000011——a
	//00000000000000000000000001111111——b
	//00000000000000000000000010000010——a+b

	//10000010——c
	//整型提升
	//11111111111111111111111110000010 - 补码
	//11111111111111111111111110000001 - 反码
	//10000000000000000000000001111110 - 原码
	//转化为十进制为-126

	printf("%d\n", c); //-126

	return 0;
}

运行结果：

-126

例2：

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

例2中的a，b要进行整形提升，但是c不需要整形提升

a，b整形提升之后，成了负数，所以表达式 a == 0xb6 ，b == 0xb600 的结果是假，但是c不发生整形提升，则表达式 c==0xb6000000 的结果是真。

所程序输出的结果是:

c

例3：

#include <stdio.h>
int main()
{
	char c = 1;
	printf("%u\n", sizeof(c));//1
	printf("%u\n", sizeof(+c));//4
	printf("%u\n", sizeof(-c));//4

	return 0;
}

运行结果：

1
4
4

例3中的c只要参与表达式运算，就会发生整形提升,表达式 +c ，就会发生提升，所以 sizeof(+c) 是4个字节。

表达式 -c 也会发生整形提升，所以 sizeof(-c) 是4个字节，但是 sizeof© ,就是1个字节。

13.2 算术转换

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

long double
double
float
unsigned long int
long int
unsigned int
int

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

警告⚠：

但是算术转换要合理，要不然会有一些潜在的问题。

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

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

1. 操作符的优先级

2. 操作符的结合性

3. 是否控制求值顺序。

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

操作符优先级

操作符	描述	用法示例	结果类型	结合性	是否控制求值顺序
（）	聚组	（表达式）	与表达式同	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	rexp	R-L	否
&	取地址	& lexp	rexp	R-L	否
sizeof	取其长度，以字节表示	sizeof rexp sizeof(类型）	rexp	R-L	否
(类型）	类型转换	(类型) rexp	rexp	R-L	否
*	乘法	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	否
<<=	以…左移	lexp <<= rexp	rexp	R-L	否
>>=	以…右移	lexp >>= rexp	rexp	R-L	否
&=	以…与	lexp &= rexp	rexp	R-L	否
^=	以…异或	lexp ^= rexp	rexp	R-L	否
|=	以…或	lexp |= lexp	rexp	R-L	否
,	逗号	rexp，rexp	rexp	L-R	是

一些问题表达式

//表达式的求值部分由操作符的优先级决定。
//表达式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在不同编译器中测试结果：非法表达式程序的结果

值	编译器
-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("%d\n", answer);//输出多少？
	return 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编译器，VS2013环境下都执行，看结果。

Linux环境的结果：

VS2019环境的结果：

看看同样的代码产生了不同的结果，这是为什么？

简单看一下汇编代码，就可以分析清楚。

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

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