目录
1、操作符分类
2、算术操作符
3、移位操作符 (二进制)
3.1 左移操作符
3.2 右移操作符
4、位操作符
5、赋值操作符
6、单目操作符
6.1 单目操作符介绍
6.2 sizeof和数组
7、关系操作符
8、逻辑操作符
9、条件操作符
10、逗号表达式
11、下标引用、函数调用和结构成员
11.1 [ ] 下标引用操作符
11.2 ( ) 函数调用操作符
11.3 访问一个结构的成员
12、表达式求值
12.1 隐式类型转换
12.2 算术转换
1、操作符分类
1. 算术操作符2. 移位操作符3. 位操作符4. 赋值操作符5. 单目操作符6. 关系操作符7. 逻辑操作符8. 条件操作符9. 逗号表达式10.下标引用、函数调用和结构成员
2、算术操作符
+ - * / %
【注】
1. 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。2. 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点 数除法。3. % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3、移位操作符 (二进制)
<< 左移操作符
>> 右移操作符
注：移位操作符的操作数只能是整数。
【补】原码，反码，补码
计算机存储的形式是补码，我们平时写的二进制都是原码
三者关系如下：
- 如果是正数的话，其原码，反码，补码相同（首位是0）
- 如果是负数的话，原码首位是1，原码取反得到反码（除符号位），反码加一得到补码。
从补码到原码也有两种方法，其中取反加一可以来回计算，体现出计算机语言设计的巧妙性。
3.1 左移操作符
移位规则：左边抛弃，右边补0
int main() { int a = 10; //00000000000000000000000000001010 int b = a << 1; //00000000000000000000000000010100->20 printf("%d\n", b); return 0; }左移有乘2的效果
3.2 右移操作符
移位规则：
- 逻辑移位：左边用0填充，右边丢弃
- 算术移位：左边用原该值的符号位填充，右边丢弃（常见）
int main() { int a = -1; //10000000000000000000000000000001--原码 //11111111111111111111111111111110--反码 //11111111111111111111111111111111--补码 int b = a >> 1; //直接取反加一 //10000000000000000000000000000001--原码--》-1 printf("%d\n", b); return 0; }
【注】对于移位运算符，不要移动负数位，这个是标准未定义的。
int num = 10; num>>-1;//error
4、位操作符
& //按位与 | //按位或 ^ //按位异或注：他们的操作数必须是整数。
【练习】
int main() { int num1 = 1; //00000000000000000000000000000001 int num2 = 2; //00000000000000000000000000000010 printf("%d\n", num1 & num2); //00000000000000000000000000000000 printf("%d\n", num1 | num2); //00000000000000000000000000000011 printf("%d\n", num1 ^ num2); //00000000000000000000000000000011 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.异或之间满足交换律，0和任何数异或等于该数。
2.可读性差
3.效率不如使用临时变量的方法
4.异或只能对整数进行交换
【练习】编写代码实现：求一个整数存储在内存中的二进制中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; } //思考这样的实现方式有没有问题？————负数问题————需要把int类型改为unsigned int //方法2： #include <stdio.h> int main() { int num = -1; int i = 0; int count = 0;//计数 for (i = 0; i < 32; i++) { if ((num>>i)&1==1) 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; //这样的写法是不是更加清晰爽朗而且易于调试。
复合赋值符：
+=-=*=/=%=>>=<<=&=|=^=这些运算符都可以写成复合的效果。比如：int x = 10; x = x+10; x += 10;//复合赋值 //其他运算符一样的道理。这样写更加简洁。
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);//这样写行不行？--不行 return 0; }关于 sizeof 其实我们之前已经见过了，可以求变量（类型）所占空间的大小。
6.2 sizeof和数组
#include <stdio.h> void test1(int arr[]) { printf("%d\n", sizeof(arr));//(2) 4或者8 本质上是指针 } void test2(char ch[]) { printf("%d\n", sizeof(ch));//(4) 4或者8 本质上是指针 } 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; }问：（ 1 ）、（ 2 ）两个地方分别输出多少？（ 3 ）、（ 4 ）两个地方分别输出多少？
//前置++和-- #include <stdio.h> int main() { int a = 10; int x = ++a; //先对a进行自增，然后对使用a，也就是表达式的值是a自增之后的值。x为11。 int y = --a; //先对a进行自减，然后对使用a，也就是表达式的值是a自减之后的值。y为10; return 0; } //后置++和-- #include <stdio.h> int main() { int a = 10; int x = a++; //先对a先使用，再增加，这样x的值是10；之后a变成11； int y = a--; //先对a先使用，再自减，这样y的值是11；之后a变成10； return 0; }
7、关系操作符
>>=<<=!= 用于测试 “ 不相等 ”== 用于测试 “ 相等 ”
这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
【注】在编程的过程中== 和=不小心写错，导致的错误。
8、逻辑操作符
逻辑操作符有哪些：
&& 逻辑与|| 逻辑或
区分
逻辑与
和
按位与
区分
逻辑或
和
按位或
1 & 2 ----> 01 && 2 ----> 11 | 2 ----> 31 || 2 ----> 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); return 0; } //程序输出的结果是什么？ //a = 1 //b = 2 //c = 3 //d = 4上述代码被称为逻辑短路或者叫短路求值。
9、条件操作符
exp1 ? exp2 : exp3
if (a > 5) b = 3; else b = -3;转换成条件表达式，是什么样？b = a>5?3:-3;2. 使用条件表达式实现找两个数中较大值。int get_max(int a,int b) { return a>b?a:b; }
10、逗号表达式
exp1 , exp2 , exp3 , …expN
逗号表达式，就是用逗号隔开的多个表达式。
逗号表达式，从左向右依次执行。整个表达式的结果是最后一个表达式的结果。
//代码1 int a = 1; int b = 2; int c = (a>b, a=b+10, a, b=a+1);//逗号表达式 //c是多少？---13 //代码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) { //业务处理 }
11、下标引用、函数调用和结构成员
11.1 [ ] 下标引用操作符
操作数：一个数组名
+
一个索引值
int arr [ 10 ]; // 创建数组arr [ 9 ] = 10 ; // 实用下标引用操作符。[ ] 的两个操作数是 arr 和 9 。//这也说明java里面数组定义比C语言里面的更严谨
11.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; }【注】我们之前用的时间函数time( )，后面的括号就是调用操作符，不能丢！
11.3 访问一个结构的成员
. 结构体 . 成员名-> 结构体指针 -> 成员名
#include <stdio.h> struct Stu { char name[10]; int age; char sex[5]; double score; }; void set_age1(struct Stu stu) { stu.age = 18; } void set_age2(struct Stu* pStu) { pStu->age = 18;//结构成员访问 } int main() { struct Stu stu; struct Stu* pStu = &stu;//结构成员访问 stu.age = 20;//结构成员访问 set_age1(stu); pStu->age = 20;//结构成员访问 set_age2(pStu); return 0; }
12、表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.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 个比特位：11111111因为 char 为有符号的 char所以整形提升的时候，高位补充符号位，即为 1提升之后的结果是：11111111111111111111111111111111// 正数的整形提升char c2 = 1 ;变量 c2 的二进制位 ( 补码 ) 中只有 8 个比特位：00000001因为 char 为有符号的 char所以整形提升的时候，高位补充符号位，即为 0提升之后的结果是：00000000000000000000000000000001// 无符号整形提升，高位补 0//【补充】有符号型的char的范围为-128~127,无符号型的char的范围为0~255
整形提升的例子:
//实例1 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; }实例 1 中的 a,b 要进行整形提升 , 但是 c 不需要整形提升。a,b整形提升之后 , 变成了负数 , 所以表达式 a==0xb6 , b==0xb600 的结果是假 , 但是 c 不发生整形提升 , 则表达式 c==0xb6000000 的结果是真.因此只能打印出c。//实例2 int main() { char c = 1; printf("%u\n", sizeof(c)); printf("%u\n", sizeof(+c)); printf("%u\n", sizeof(-c)); return 0; }实例 2 中的 ,c 只要参与表达式运算 , 就会发生整形提升 , 表达式 +c , 就会发生提升 , 所以 sizeof(+c) 是 4 个字节. 表达式 - c 也会发生整形提升 , 所以 sizeof( - c) 是 4 个字节 , 但是 sizeof(c) , 就是 1 个字节 .
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换
。
long doubledoublefloatunsigned long intlong intunsigned intint
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运算。
【注】但是算术转换要合理，要不然会有一些潜在的问题
float f = 3.14 ;int num = f ; // 隐式转换，会有精度丢失
![[附源码]java毕业设计览宏公司会议管理系统](https://img-blog.csdnimg.cn/c20d63dbc61440acaddbf1a478550b7a.png)
![[附源码]java毕业设计企业人力资源管理系统](https://img-blog.csdnimg.cn/5ef38829087847fb918508af39d32322.png)
