目录
- 一、前言
- 二、操作符分类
- 三、算术操作符
- 四、移位操作符
- 1、左移操作符
- 2、右移操作符
- 五、位操作符
- 拓展
- 1、不能创建临时变量（第三个变量），实现两个数的交换。
- 2、编写代码实现：求一个整数存储在内存中的二进制中1的个数。
- 六、赋值操作符
- 七、单目操作符
- 1、简介
- 1、！
- 2、&和*
- 3、sizeof
- 2、sizeof和数组
- 3、+ +和- -运算符
- 4、~
- 5、（）
- 八、关系操作符
- 九、 逻辑操作符
- 十、条件操作符
- 十一、逗号表达式
- 十二、下标引用、函数调用和结构成员
- 1、下标引用操作符 [ ]
- 2、（）函数调用操作符
- 3、访问一个结构的成员
- 十三、表达式求值
- 1、隐式类型转换
- 1、整型提升的意义
- 2、如何进行整体提升呢？
- 2、算术转换
- 3、操作符的属性
- 一些问题表达式
- 表达式1
- 表达式2
- 表达式3
- 表达式4
- 表达式5
一、前言
- 本人是一名小白，这一篇是记录我C语言学习中的操作符的所学所得，仅为简单的认识下C语言中的各个知识。
二、操作符分类
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
三、算术操作符
+ - * / %
- 除了 % 操作符只作用于整数之外，其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作符如果两个操作数都为整数，执行整数除法，结果为商。而只要有浮点数执行的就是浮点数除法，从而得到小数的结果。
#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，扩大二倍
- 举例
- 正整数
#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;
}
运算结果
- 负整数
#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、右移操作符
首先右移运算分两种：
- 逻辑移位
左边用0填充，右边丢弃 - 算术移位
左边用原该值的符号位填充，右边丢弃
- 注意：是哪种移动方式，编译器并没有明确规定，取决于编译器。但大部分是算数移位。
- 举例：
#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、操作符的属性
- 复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
- 两个相邻的操作符先执行哪个？
取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级见下图（从上到下，优先级从高到低）
| 操作符 | 描述 | 用法示例 | 结果类型 | 结核性 | 是否控制求值顺序 |
|---|---|---|---|---|---|
| () | 聚组 | （表达式） | 与表达式相同 | 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
ab + cd + e*f
- 表达式1在计算的时候，由于 * 比 + 的优先级高，只能保证，的计算是比+早，但是优先级并不能决定第三个比第一个+早执行
所以表达式1的计算顺序可能是：
ab
cd
ab+cd
ef
ab+cd+ef
或者
ab
cd
ef
ab+cd+ef
表达式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编译器所得结果不同。
原因：这段代码第一个+在执行的时候，第三个++是否执行，这个是不确定的，
总结： 我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
