目录
操作符分类
算术操作符
+ - * / %
- % 操作符的两个操作数必须为整数。返回值的是整除之后的余数。
- 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
- 除了 % 操作符之外，其他的几个操作符都可以作用于整数和浮点数。
- 直接输入的小数默认判断为double类型，在数字后面加个f，就会转化为float型了
移位操作符
<< >>
- 箭头指向哪边就是哪个方向的移位操作符，移位操作符的操作数只能是整数。
- 移位指的是移动二进制位，不要移动负数位！
- 左移操作符：左边丢弃，右边补0。
- 右移操作符：右移运算是将一个二进制位的操作数按指定移动的位数向右移动，移出位被丢弃，左边移出的空位或者一律补0，或者补符号位，c的编译器一般都是默认补符号位
- 算数右移：右边丢弃，左边补原符号位
- 逻辑右移：右边丢弃，左边补0
- 移位不会改变操作数的本身数值
整数的二进制表示形式：3种
原码：直接根据数值写出的二进制序列
反码：原码的符号位，其余位按位取反
补码：反码+1，就是补码
正数原反补码都相同，而负数按补码形式存在内存中，对补码进行位运算后，将补码转化为反码再转化为原码形式表达出来
位操作符
& | ^&按（二进制）位与：二者同为1则为1
| 按（二进制） 位或：一个为1则为1
^按（二进制） 位异或：二者相同则为0，相异为1
异或的运用:
a^a=0
0^a=a
由以上两个基本概念可以推出→a^b^b=a^(b^b)=a^0=a程序题：不能创建临时变量（第三个变量），实现两个数的交换。
int main() { int a = 3; int b = 5; printf("a=%d b=%d\n", a, b); //int tmp = a;临时变量交换 //a = b; //b = tmp; //a = a + b;这种写法交换可能会造成溢出 //b = a - b; //a = a - b; a = a ^ b; b = a ^ b; a = a ^ b; printf("a=%d b=%d\n", a, b); return 0; }
赋值操作符
= 赋值操作符可以连续使用，从右向左赋值，但不可以在定义变量时对变量进行连续赋值。
以下为复合赋值符：+= -= *= /= %= >>= <<= &= |= ^=
单目操作符
定义：只有一个操作数的称为单目操作符
! 逻辑反操作 – 负值 + 正值 & 取地址 sizeof 操作数的类型长度（以字节为单位） ~ 对一个数的二进制按位取反 — 前置、后置– ++ 前置、后置++ *间接访问操作符(解引用操作符) (类型) 强制类型转换
- sizeof对于变量名可以省略后面的括号，但是对于数据类型不能省。
- sizeof计算数组的大小时候，也可以写成数组的数据类型[元素个数]。比如sizeof(int[10])
- sizeof括号中放的表达式不参与运算
关系操作符
> >= < <= != 用于测试“不相等” == 用于测试“相等”比较两个字符串相等，不能使用 ==，必须使用strcmp
逻辑操作符
&& || ！
- 逻辑与运算a&&b中，如果a为假，则表达式b不运算
- 逻辑或运算a||b中，如果a为真，则表达式b不运算
条件操作符
?:又称三目操作符 exp1?exp2:exp3
- 如果exp1成立，则exp2计算，作为表达式的值，exp3不计算。
- 如果exp1不成立，则exp3计算，作为表达式的值，exp2不计算。
逗号表达式
逗号表达式就是用逗号隔开的多个表达式，从左向右依次计算，但是整个表达式的结果是最后一个表达式的结果。
其形式为：(exp1,exp2,exp3...)
下标引用、函数调用和结构成员
下标引用操作符 [] 是双目操作符，它有两个操作数-数组名和下标
函数调用操作符(),操作数-一个是函数名，其余是传给函数的参数
结构成员访问操作符：.用.操作符可以找出结构体变量里面的结构体成员，格式：结构体变量名.结构体成员名->结构体指针->成员名函数调用示例：
#include <stdio.h> void test1() { printf("hehe\n"); } void test2(const char* str) { printf("%s\n", str); } int main() { test1(); //用（）作为函数调用操作符。 test2("hello sb.");//用（）作为函数调用操作符。 return 0; }补充一个细节重点：%s的打印是从首个地址开始打印，然后不断向后打印，直到\0出现才结束打印。
结构成员访问操作符使用示例：
#include <stdio.h> struct Book { //结构体成员（成员变量） char name[20]; char id[20]; int price; }; int main() { struct Book b = {"C语言程序设计","C202115311103",55};//定义b是结构体Book类型 printf("%s %s %d",b.name,b.id,b.price);//这里的b就是结构体变量名，后面的就是结构体成员名 struct Book * pb=&b;//取出结构体的地址，存放在结构体Book类型的指针内 //如果想要通过pb间接访问b：*pb解引用找到b printf("%s %s %d",(*pb).name,(*pb).id,(*pb).price); //pb既然是指针变量，那么它也可以直接指向结构体的成员 printf("%s %s %d", pb->name, pb->id, pb->price); }
表达式求值
表达式的求值顺序一部分由操作符的优先级和结合性决定
有些表达式的操作数在求值过程需要转化为其他类型
隐式类型转换
定义：C语言的整型算术运算总是至少以缺省(即默认选择)整型类型的精度来进行的，为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器的操作数的字节长度 一般就是int的字节长度，同时也是CPU的通用寄存器的长度。 因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度。 通用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低于int字节数的，都要进行整形提升，即short和char只要参与表达式运算,就会发生整形提升
实例2：
#include <stdio.h> int main() { char a = 3; char b = 127; //首先3是一个整形，二进制序列为 //00000000000000000000000000000011 //而char的大小是1个字节，只提供8个二进制位，所以会发生截断 //即值变为了0000 0011 //而127的二进制序列为 //00000000000000000000000001111111 //阶段后变为了0111 1111 //然后a+b= 1000 0010 char c = a + b; //发现a，b都是char类型的，没有达到int的大小 //这里就会发生整形提升，高位补充符号位 //a 0000 0000 0000 0000 0000 0000 0000 0011 //b 0000 0000 0000 0000 0000 0000 0111 1111 //+ 0000 0000 0000 0000 0000 0000 1000 0010 //然后存入c的时候，又要发生截断，变为1000 0010 printf("%d",c); //%d是以整形打印，于是又要将c转为int，于是高位补符号位，得到了：1111 1111 1111 1111 1111 1111 1000 0010 //因为是负数，所以是以补码形式存储，要将其转为反码再转为原码才是实际所见值 //补码=1111 1111 1111 1111 1111 1000 0010 //反码=1111 1111 1111 1111 1111 1000 0001 //原码=1000 0000 0000 0000 0000 0111 1110 即-126 //所以最终打印结果为-126 return 0; }
算术转换
定义：如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换
long double double float unsigned long int long int unsigned int int如果某个操作数的类型比起另一个的排名较低，那么首先要转换为另外一个操作数的类型后执行运算。(即精度低的向精度高的进行转换)
算数转换要合理，否则会造成精度丢失。
操作符的属性
1.操作符的优先级(优先级决定了计算顺序)
2.操作符的结合性（优先级不起作用时，结合性起作用）
3.是否控制求值顺序
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性
优先级
运算符
名称或含义
使用形式
结合方向
说明
1
[]
数组下标
数组名[常量表达式]
左到右
()
圆括号
（表达式）/函数名(形参表)
.
成员选择（对象）
对象.成员名
->
成员选择（指针）
对象指针->成员名
2
–
负号运算符
-表达式
右到左
单目运算符
(类型)
强制类型转换
(数据类型)表达式
++
自增运算符
++变量名/变量名++
单目运算符
—
自减运算符
–变量名/变量名–
单目运算符
*
取值运算符
*指针变量
单目运算符
&
取地址运算符
&变量名
单目运算符
!
逻辑非运算符
!表达式
单目运算符
~
按位取反运算符
~表达式
单目运算符
sizeof
长度运算符
sizeof(表达式)
3
/
除
表达式/表达式
左到右
双目运算符
*
乘
表达式*表达式
双目运算符
%
余数（取模）
整型表达式/整型表达式
双目运算符
4
+
加
表达式+表达式
左到右
双目运算符
–
减
表达式-表达式
双目运算符
5
<<
左移
变量<<表达式
左到右
双目运算符
>>
右移
变量>>表达式
双目运算符
6
>
大于
表达式>表达式
左到右
双目运算符
>=
大于等于
表达式>=表达式
双目运算符
<
小于
表达式<表达式
双目运算符
<=
小于等于
表达式<=表达式
双目运算符
7
==
等于
表达式==表达式
左到右
双目运算符
!=
不等于
表达式!= 表达式
双目运算符
8
&
按位与
表达式&表达式
左到右
双目运算符
9
^
按位异或
表达式^表达式
左到右
双目运算符
10
|
按位或
表达式|表达式
左到右
双目运算符
11
&&
逻辑与
表达式&&表达式
左到右
双目运算符
12
||
逻辑或
表达式||表达式
左到右
双目运算符
13
?:
条件运算符
表达式1? 表达式2: 表达式3
右到左
三目运算符
14
=
赋值运算符
变量=表达式
右到左
/=
除后赋值
变量/=表达式
*=
乘后赋值
变量*=表达式
%=
取模后赋值
变量%=表达式
+=
加后赋值
变量+=表达式
-=
减后赋值
变量-=表达式
<<=
左移后赋值
变量<<=表达式
>>=
右移后赋值
变量>>=表达式
&=
按位与后赋值
变量&=表达式
^=
按位异或后赋值
变量^=表达式
|=
按位或后赋值
变量|=表达式
15
,
逗号运算符
表达式,表达式,…
左到右
从左向右顺序运算
一些问题表达式
代码1:
//表达式的求值部分由操作符的优先级决定。 //表达式1 a*b + c*d + e*f注释：代码在计算的时候，由于*比+的优先级高，只能保证*的计算是比+早，但是优先级并不能决定第三个*比第一个+早执行。
所以表达式的计算机顺序就可能是：1.a*b 2.c*d 3.a*b+c*d 4.a*b + c*d + e*f 或者 1.a*b 2.c*d 3.e*f 4.a*b + c*d 5.a*b + c*d + e*f而abcdef是表达式，里面一旦有一个可以影响到其他的表达式，只要计算顺序不同了，就有可能导致运算结果不同。
代码2：
//表达式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);//输出多少？ return 0; }虽然代码4在大多数的编译器上求得结果都是相同的。
但是上述代码 answer = fun() – fun() * fun(); 中我们只能通过操作符的优先级得知：先算乘法， 再算减法。 函数的调用先后顺序无法通过操作符的优先级确定。所以这也是一串垃圾代码代码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; }这串代码更是垃圾，它的运行结果竟然是12，在linux运行则是10。
简单看一下汇编代码，就可以分析清楚。这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。总结：我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题 的。作为一个合格的程序员要避免写出这样的垃圾代码。
本章完，祝有所收获。
745
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
