操作符从浅入深的讲解
1. 操作符的分类
2. ⼆进制和进制转换
3. 原码、反码、补码
4. 移位操作符
5. 位操作符：&、|、^、~
6. 单⽬操作符
7. 逗号表达式
8. 下标访问[]、函数调⽤()
9. 结构成员访问操作符
10. 操作符的属性：优先级、结合性
11. 表达式求值
1.操作符的分类
以下就是大部分的操作符
算术操作符： + 、- 、* 、/ 、%
移位操作符: << >>
位操作符: & | ^
赋值操作符: = 、+= 、 -= 、 *= 、 /= 、%= 、<<= 、>>= 、&= 、|= 、^=
单⽬操作符： ！、++、--、&、*、+、-、~ 、sizeof、(类型)
关系操作符: > 、>= 、< 、<= 、 == 、 !=
逻辑操作符： && 、||
条件操作符： ? :
逗号表达式： ,
下标引⽤： []
函数调⽤： ()
结构成员访问： . 、->
2.二进制和进制转换
我们都知道计算机只认识二进制，而除了二进制，还有八进制，十进制，十六进制。他们的不同仅在于对一个数值的表达形式不同。
例如∶数值15的各种进制表达形式
15的2进制：1111 15的8进制：17 15的10进制：15 15的16进制：F！！！十六进制的数值前要写0x
，而八进制的数值前要写0。
我们重点了解一下二进制
首先我们要先从了解十进制，关于十进制我们知道其一些底层逻辑。
十进制中满十进一
十进制中每一位的数字都由0到9组成
而二进制也是一样的
二进制满二进一
二进制中每一位的数字由0和1组成
2.1二进制转换十进制
十进制的123代表的值是一百二十三，为什么这样呢？因为十进制的每一位都有权重，十进制的数字从左向右是个位，十位，百位……，每一位的权重分别是十的零次方，十的一次方，十的平方……
如下图所示∶
二进制与十进制类似，不过二进制的每一位权重从右到左分别是二的零次方，二的一次方，二的平方……
例如二进制的1101，怎么理解呢？
2.1.1 十进制转换成二进制数字
2.2二进制转换成八进制和十六进制
2.2.1二进制转换成八进制
八进制的每一位数字是0到7，如果各自写成二进制，最多有三个二进制，比如7的二进制是111，所以二进制转换成八进制时，从二进制序列右边到左边每3个二进制转换成一个八进制，剩余不够3个二进制位直接换算
比如∶二进制的01101011，换成八进制∶0153，0开头的数字，会被当做八进制。
2.2.2二进制转换成十六进制
十六进制的每一位数字是0到9，a到f（代表10到15）。各自写成二进制，最多有4个二进制，比如f的二进制是1111，所以二进制转换成十六进制，二进制序列从右到左每4位组成一个十六进制数，剩余不够的直接转换，
例如∶二进制的01101011，换成十六进制∶0x6b，16进制表示的时候前面加0x。
3.原码、反码、补码
整数的二进制表达方式有三种，即原码、反码、补码
有符号整数的三种表达方式均有符号位和数值位，二进制中，最左边一位是符号位，其余都是数值位，
符号位中0代表“正”，1代表“负”。
正整数的原、反、补码都相同。
负整数的三种表⽰⽅法各不相同。
原码：直接将数值按照正负数的形式翻译成⼆进制得到的就是原码。
反码：将原码的符号位不变，其他位依次按位取反就可以得到反码。
补码：反码+1就得到补码。补码得到原码也是可以使⽤：取反，+1的操作。
⽆符号整数的三种 2 进制表⽰相同，没有符号位，每⼀位都是数值位
对于整形来说：数据存放内存中其实存放的是补码。
为什么呢？
在计算机系统中，数值⼀律⽤补码来表⽰和存储。原因在于，使⽤补码，可以将符号位和数值域统⼀
处理；同时，加法和减法也可以统⼀处理（CPU只有加法器）此外，补码与原码相互转换，其运算
过程是相同的，不需要额外的硬件电路。
4.移位操作符
＜＜左移操作符
＞＞右移操作符
移位操作符的操作数只能是整数
4.1左移操作符
移位规则∶左边抛弃，右边补0
#include <stdio.h> int main() { int num = 10; int n = num << 1; printf("n = %d\n", n); printf("num = %d\n", num); return 0; }4.2右移操作符
移位规则∶右移操作运算有两种∶
1.逻辑右移∶左边用0填充，右边丢弃
2.算数右移∶左边用符号位填充，右边丢弃
#include <stdio.h> int main() { int num = -1; int n = num >> 1; printf("n = %d\n", n); printf("num = %d\n", num); return 0; }逻辑右移一位
算数右移一位
！！！对于移位操作符，不要移动负数位，这个是标准未定义
例如∶
int num = 10; num >> -1;5.位操作符：&、|、^、~
位操作符是在数值的二进制位进行操作的，其次结果是补码，如果是正数，不用转换，如果是负数，要符号位不变，其余位要转换成原码，然后得到它代表的负数。
位操作符有：
& //按位与（对应位有1则为1） | //按位或（对应位都是1则为1） ^ //按位异或（对应位不同则为1） ~ //按位取反（二进制0变1，1变0）#include <stdio.h> int main() { int num1 = -3; int num2 = 5; printf("%d\n", num1 & num2); printf("%d\n", num1 | num2); printf("%d\n", num1 ^ num2); printf("%d\n", ~0); return 0; }运行结果如下：
#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; }用异或的方式可以这样实现快速算出交换后的结果，还不会占用额外的内存
//⽅法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; } //这样是对二进制的每一位进行了判断，而且可以对正数和负数都进行判断 //但能不能对这个方法进行优化呢？ //⽅法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; } //虽然这个方法优化了方法二对每个数的判断，而且没有额外的移位操作，但是这种方法很难想到13的2进制序列：00000000000000000000000000001101将第5位置为1后：00000000000000000000000000011101将第5位再置为0：00000000000000000000000000001101
#include <stdio.h> int main() { int a = 13; a = a | (1 << 4); printf("a = %d\n", a); a = a & ~(1 << 4); printf("a = %d\n", a); return 0; }6.单⽬操作符
1. ! 逻辑非
把逻辑值取反，规则是“非0为真，0为假”，取反后真变假、假变真。
- 比如 !0 的结果是1（真）， !5 的结果是0（假）。
- 常用场景： if(!flag) ，当 flag 为0时条件成立。
2. ++ 自增
让操作数的值加1，分两种用法：
- 前置自增 ++a ：先把 a 的值加1，再用加完的结果参与后续运算。
- 后置自增 a++ ：先用 a 当前的值参与运算，运算结束后再把 a 的值加1。
3. -- 自减
和自增类似，只是让操作数的值减1，也分前置和后置：
- 前置自减 --a ：先减1，再参与运算。
- 后置自减 a-- ：先参与运算，再减1。
4. & 取地址符
获取变量在内存中的地址，常用来给指针变量赋值。
- 比如 int *p = &a; ，意思是让指针 p 指向变量 a 的内存地址。
5. * 解引用符
和取地址符相反，用来访问指针指向的内存地址里存的值。
- 比如 *p = 10; ，就是把10赋值给 p 指针指向的那个变量。
6. + 正号
只是显式表示一个数是正数，对数值本身没有任何改变。
- 比如 int a = +5; 和 int a = 5; 效果完全一样。
7. - 负号
对数值取反，得到它的相反数。
- 比如 int b = -a; ，如果 a 是3，那 b 就是-3；如果 a 是-2，那 b 就是2。
8. ~ 按位取反
把整数的二进制位全部取反，0变1、1变0，是位运算里的操作符。
- 比如32位系统里， ~0 会把所有0位变成1，结果就是-1。
9. sizeof 求字节数
获取变量或数据类型在内存中占的字节数，它不是函数，是C语言的内置操作符。
- 比如 sizeof(int) 在多数系统里结果是4， sizeof(char) 结果永远是1。10. (类型) 强制类型转换
把表达式的结果强制转换成指定的数据类型，常用于解决类型不匹配的问题。
- 比如 (float)5 / 2 ，先把5转成浮点数5.0，再除以2，结果是2.5，而不是整数除法的2。
7. 逗号表达式
表达形式
exp1, exp2, exp3, …expN
8.下标访问[]、函数调⽤()
8.1[ ] 下标引⽤操作符
操作数：⼀个数组名 + ⼀个索引值(下标)
例如：
intarr[10]={0};//创建并初始化数组arr[9] =10;//实⽤下标引⽤操作符。[ ]的两个操作数是arr和9。
8.2 函数调⽤操作符
#include <stdio.h> void test1() { printf("hehe\n"); } void test2(const char *str) { printf("%s\n", str); } int main() { test1(); //这⾥的()就是作为函数调⽤操作符。 test2("hello world.");//这⾥的()就是函数调⽤操作符。 return 0; }运行结果：
9. 结构成员访问操作符
9.1 结构体
C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学⽣，描述⼀本书，这时单⼀的内置类型是不⾏的。
描述⼀个学⽣需要名字、年龄、学号、⾝⾼、体重等；
描述⼀本书需要书名、作者、出版社、定价等。C语⾔为了解决这个问题，增加了结构体这种⾃定义的数据类型，让程序员可以⾃⼰创造适合的类型。
9.1.1 结构的声明
structStu{charname[20];//名字intage;//年龄charsex[5];//性别charid[20];//学号};//分号不能丢
9.1.2 结构体变量的定义和初始化
//代码1 struct Point { int x; int y; }p1; //声明类型的同时定义变量p1 struct Point p2; //定义结构体变量p2 //代码2 struct Point p3 = {10, 20}; struct Stu //类型声明 { char name[15];//名字 int age; //年龄 }; struct Stu s1 = {"zhangsan", 20};//初始化 struct Stu s2 = {.age=20, .name="lisi"};//指定顺序初始化 //代码3 struct Node { int data; struct Point p; struct Node* next; }n1 = {10, {4,5}, NULL}; //结构体嵌套初始化 struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化9.2 结构成员访问操作符
9.2.1 结构体成员的直接访问
#include <stdio.h> struct Point { int x; int y; }p = {1,2}; int main() { printf("x: %d y: %d\n", p.x, p.y); return 0; }9.2.2 结构体成员的间接访问
#include <stdio.h> struct Point { int x; int y; }; int main() { struct Point p = {3, 4}; struct Point *ptr = &p; ptr->x = 10; ptr->y = 20; printf("x = %d y = %d\n", ptr->x, ptr->y); return 0; }10. 操作符的属性：优先级、结合性
10.1 优先级
3+4*5;
表达式3 + 4 * 5⾥⾯既有加法运算符（+），⼜有乘法运算符（*）。由于乘法的优先级⾼于加法，所以会先计算4 * 5，⽽不是先计算3 + 4。
10.2 结合性
如果两个运算符优先级相同，优先级没办法确定先计算哪个了，这时候就看结合性了，则根据运算符 是左结合，还是右结合，决定执⾏顺序。⼤部分运算符是左结合（从左到右执⾏），少数运算符是右 结合（从右到左执⾏），⽐如赋值运算符（ = ）。
5*6/2;
运算符的优先级顺序很多，下⾯是部分运算符的优先级顺序（按照优先级从⾼到低排列），建议⼤概记住这些操作符的优先级就⾏，其他操作符在使⽤的时候查看下⾯表格就可以了。•圆括号（ ()）•⾃增运算符（ ++），⾃减运算符（--）•单⽬运算符（ +和-）•乘法（ *），除法（/）•加法（ +），减法（-）•关系运算符（ <、>等）•赋值运算符（ =）由于圆括号的优先级最⾼，可以使⽤它改变其他运算符的优先级。
11. 表达式求值
11.1 整型提升
C语⾔中整型算术运算总是至少以缺省（默认）整型类型的精度来进⾏的。为了获得这个精度，表达式中的字符和短整型操作数在使⽤之前被转换为普通整型，这种转换称为整型提升。
表达式的整型运算要在CPU的相应运算器件内执⾏，CPU内整型运算器(ALU)的操作数的字节⻓度⼀般就是int的字节⻓度，同时也是CPU的通⽤寄存器的⻓度。因此，即使两个char类型的相加，在CPU执⾏时实际上也要先转换为CPU内整型操作数的标准长度。通⽤CPU（general-purpose CPU）是难以直接实现两个8⽐特字节直接相加运算（虽然机器指令中 可能有这种字节相加指令）。所以表达式中各种⻓度可能⼩于int⻓度的整型值，都必须先转换为int或unsigned int，然后才能送⼊CPU去执⾏运算。
1. 有符号整数提升是按照变量的数据类型的符号位来提升的2. 无符号整数提升，高位补0
//负数的整形提升
char c1 = -1;
变量c1的⼆进制位(补码)中只有8个⽐特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111//正数的整形提升
char c2 = 1;
变量c2的⼆进制位(补码)中只有8个⽐特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，⾼位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001//⽆符号整形提升，⾼位补0
11.2 算术转换
long doubledoublefloatunsigned long intlong intunsigned intint
11.3 问题表达式解析
11.3.1 表达式1
a * b + c * d + e * f
表达式1在计算的时候，由于 *比 + 的优先级高，只能保证， * 的计算是比 + 早，但是优先级并不能决定第三个 * ⽐第⼀个 + 早执行。所以表达式的计算机顺序就可能是：
a*bc*da*b + c*de*fa*b + c*d + e*f或a*bc*de*fa*b + c*da*b + c*d + e*f
11.3.2 表达式2
c + --c;
11.3.4 表达式3
#include <stdio.h> int fun() { static int count = 1; return ++count; } int main() { int answer; answer = fun() - fun() * fun(); printf( "%d\n", answer);//输出多少？ return 0; }