目录：
1. 操作符分类：
算术操作符
移位操作符
位操作符
赋值操作符
单目操作符
关系操作符
逻辑操作符
条件操作符
逗号表达式
下标引用、函数调用和结构成员
2. 算术操作符
+ - * / %
下表显示了 C 语言支持的所有算术运算符。假设变量 A 的值为 10，变量 B 的值为 20，则：
- 除了 % 操作符之外，其他的几个操作符可以作用于整数和浮点数。
- 对于 / 操作符如果两个操作数都为整数，执行整数除法。而只要有浮点数执行的就是浮点数除法。
- % 操作符的两个操作数必须为整数。返回的是整除之后的余数。
3. 移位操作符
左移操作符 <<
右移操作符 >>
注：移位操作符的操作数只能是整数。
位移操作符移动的是二进制
为了跟好地进行位移操作符的讲解，这里我们需要对进制有初步的了解
关于移位操作符，需要认识源码，反码，补码，从而对移位操作进行深度理解：
3.1 左移操作符
移位规则：
左边抛弃、右边补0
3.2 右移操作符
移位规则：
首先右移运算分两种：
- 逻辑移位
左边用0填充，右边丢弃- 算术移位
左边用原该值的符号位填充，右边丢弃
具体采用哪种移位，取决于编译器，一般编译器采用算数移位
警告⚠ ：
对于移位运算符，不要移动负数位，这个是标准未定义的。
例如
int num = 10; num>>-1;//error
4. 位操作符
注：1.为操作符的操作数必须是整数。
2.位操作符作用于二进制数列
| 位操作符 | 名称 | 作用 |
| & | 按位与 | 有0则0，同1则1 |
| | | 按位或 | 有1则1 |
| ^ | 按位异或 | 相同为0，相异为1 |
按位与示例：
按位或示例：
按位异或示例：
不能创建临时变量（第三个变量），实现两个数的交换
一种巧妙的算法
如上算法存在缺陷，a+b若太大会溢出，下面让我们使用异或操作符来实现：
需要用到：
1.相同为0，0与任何数异或结果都为这个数
2.异或支持交换律
//3^3 = 0 //5^5=0 //3^5=6 //3^5^5=3 //3^5^3=5 // //000 //011 //011 //011 //101 //110 //a^a=0 //0^a=a //异或是支持交换律 //3^5^3 //3^3^5 // int main() { int a = 3; int b = 5; a = a ^ b; b = a ^ b;//b=a ^ b ^ b a = a ^ b;//a^b^a //a = a + b; //b = a - b; //a = a - b; printf("a=%d b=%d\n", a, b); return 0; }
练习：
编写代码实现：求一个整数存储在内存中的二进制中1的个数。
参考代码：
//方法1
#include <stdio.h> int count_bit( int m) { int count = 0; while (m) { if (m % 2 == 1) count++; m /= 2; } return count; } int main() { int n = 0; scanf("%d", &n); int num = count_bit(n); printf("%d\n", num); return 0; }
这种方法明显是有错误的，如果输入的是负数，无法输出正确的值，因此我们可以联想到无符号
int count_bit(unsigned int m)
若将上述函数的自定义声明改为这个，则可以避免上述问题的出现。
接下来我们运用操作符实现这个程序：
//方法2： #include <stdio.h> int count_bit(n) { int i = 0; int count = 0; for (i = 0; i < 32; i++) { if (1 == ((n >> i) & 1)) count++; } return count; } int main() { int n = 0; scanf("%d", &n); int num = count_bit(n); printf("%d\n", num); return 0; }
还能不能更加优化，上述两种方式都必须循环32次。
//方法3：
int count_bit(int m) { int count = 0; while (m) { m = m & (m - 1); count++; } return count; } int main() { int n = 0; scanf("%d", &n); int num = count_bit(n); printf("%d\n", num); return 0; } //n=11 //n = n&(n-1) //1011 - n //1010 - n-1 //1010 - n //1001 - n-1 //1000 - n //0111 - n-1 //0000 - n //根据上述规律可知，有几个n&(n-1)就有多少个1
这种方式很好，达到了优化的效果，但是难以想到。
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 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
– 前置、后置–
++ 前置、后置++
* 间接访问操作符(解引用操作符) (类型) 强制类型转换
- ！举例
int main() { int flag = 0; //if (!flag) if(flag == 0) { printf("hehe\n"); } return 0; }
- &和解引用操作符的举例
int main() { int a = 10; char c = 0; // printf("%p\n", &a);//取出地是二进制数列 // printf("%p\n", &c); int* pa = &a;//& - 取地址操作符 pa是指针变量 int*是类型 //*pa = 20;//* - 解引用操作符 把a拿出来进行赋值 *pa = 20; return 0; }
- sizeof操作符举例
int main() { short s = 10; int a = 2; s = a + 5; printf("%zu\n", sizeof(s = a + 5));//输出结果为2，sizeof（）内部放的表达式不会计算 printf("%d\n", s);//，输出结果为10 int a = 10; int* p; int arr[10]; printf("%zu\n", sizeof(a));//int 4 printf("%zu\n", sizeof a);//int 4 printf("%zu\n", sizeof(int));//int 4 //printf("%zu\n", sizeof int);//err printf("%zu\n", sizeof(p));//int* 4 printf("%zu\n", sizeof(arr));//int [10] 40 printf("%zu\n", sizeof(arr[10]));//int 4 return 0; }
⭐️ 这里需要注意的是sizeof（数组名）是指数组整体的类型长度，而不是数组首元素的类型长度，sizeof（）内部放的表达式不会计算。
- 原理：
在文件转向可执行程序的时候在编译阶段，编译器就进行了判断，进行了截断把后面括号中两个字节的内容给了short类型
- ~按位取反操作符
- 代码与原理展示：
int main() { int a = 0; /*00000000000000000000000000000000 - ~按位取反 11111111111111111111111111111111 - 内存中-补码 11111111111111111111111111111110 -反码（补码减1） 10000000000000000000000000000001 -源码（反码符号位不变其他位按位取反） -1*/ printf("%d\n", ~a); return 0; }
上面的内容仅仅是铺垫，相信看完下面的内容你会对~（按位取反操作符）有更加深入的了解
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; }
6.2 sizeof 和 数组
#include <stdio.h> void test1(int arr[]) { printf("%d\n", sizeof(arr));//(结果4) } void test2(char ch[]) { printf("%d\n", sizeof(ch));//(结果4) } int main() { int arr[10] = { 0 }; char ch[10] = { 0 }; printf("%d\n", sizeof(arr));//(结果40) printf("%d\n", sizeof(ch));//(结果10) test1(arr); test2(ch); return 0; }
参阅了如上代码是否有所疑惑，且看详解：
- ++ - -运算符
关于++和–运算符，前面的文章中提到过，但下面的图片也是一目了然
若图片看不太懂，还有代码供参考😏
//++和--运算符 //前置++和-- #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; }
- 强制类型转换
如图，当我们将一个小数想要赋值给int型的变量时，编译器会报错，这里就需要用到强制类型转换，下面的代码中我们就运用了强制类型转换，只要认真观察区别，就可以学会
int main() { int a = (int)3.14; printf("%d\n", a); return 0; }
这里输出的值自然为整数3
7. 关系操作符
关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
这些关系运算符比较简单，没什么可讲的，但是我们要注意一些运算符使用时候的陷阱。
注意：
在编程的过程中== 和=不小心写错，导致的错误。
如图，如果因为少写了等号=，如果常量放在后面，编译器会认为是赋值语句而不报错，但常量放在前面，少写了等号，编译器必然会报错。
因此，在判断变量和常量是否相等时建议使用 if(10==a);这种写法。
int main()
{
char arr[] = “abcdef”;
==不能比较2个字符串的内容，实际上比较的是2个字符串的首字符的地址,所以这样写是错误的
if (arr == “abcdef”)
{
printf(“==\n”);
}
return 0;
}
8. 逻辑操作符
逻辑操作符有哪些：
&& 逻辑与
|| 逻辑或
区分逻辑与和按位与
区分逻辑或和按位或
1&2----->0
1&&2---->1
1|2----->3
1||2---->1
逻辑与和或的特点：
若逻辑或运算符左边操作数的值为1，则就不继续执行其右边的操作数。
“&&” 同理，若左边的操作数为0，则就不继续执行其右边的操作数
int main() { int a = 3; int b = 0; if (a && b) //这里的&&仅仅判断真假，如果两边都是真，则继续执行，非0即为真 //if (a || b) //同样的，有真则为真 { printf("呵呵\n"); } return 0 ; }
int main() { int age = 20; 18~36 青年 if (age >= 18 && age <= 36) { printf("青年\n"); }
int main() { int year = 2000; if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) printf("闰年");//这里的&&是并且的意思 ||是或的意思 return 0; }
360笔试题
#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\n b = %d\n c = %d\nd = %d\n", a, b, c, d); return 0; }
//程序输出的结果是什么？
因为a++先使用a的值，a==0，&&只要有a就为假，所以后面不会运行，自然值也不变，而a最后还要++，所以运行结果如下
这里有几个变式，如果可以都计算正确，说明该知识点已经掌握，如果没有，则需要认真思考
输出结果为2335；
运行结果为2234，因为a是1，||后面不管是几都为真，所以后面不计算直接跳过，而a还要++
结果为1334
9. 条件操作符
exp1 ? exp2 : exp3
int main() { int a = 3; int b = 0; if (a > 5) b = 3; else b = -3; return 0; }
转换成条件表达式，是什么样？
b = ((a > 5) ? 3 : -3);
2.使用条件表达式实现找两个数中较大值。
int m = (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) { //业务处理 }
通过如上代码，我们可以看出，代码3中，相对于用while循环写出的代码，用逗号表达式写出来的代码更加简洁。
11. 下标引用、函数调用和结构成员
- 1. [ ] 下标引用操作符
注意：[ ]不是定义数组时的操作符，而是在要访问数组的第某个元素时所使用的操作符
arr[4];访问数组的第5个元素，
这里的[ ]就交下标引用操作符，
操作数是arr和4
操作数：一个数组名 + 一个索引值 - 2. ( ) 函数调用操作符
接受一个或者多个操作数：第一个操作数是函数名，剩余的操作数就是传递给函数的参数。
void test(int x, int y) { } void test2() {} int main() { test2(); //操作数：test2 test(3, 4);//()函数调用操作符 //操作数：test,3,4 return 0; }
- 3. 访问一个结构的成员
. 结构体.成员名
-> 结构体指针->成员名
//结构体成员
//书：书名 + 定价
代码演示：
struct Book { char name[20]; int price; }; int main() { struct Book sb = { "C语言", 55 }; printf("%s %d\n", sb.name, sb.price);//结构体变量.结构体成员名 struct Book* ps = &sb; printf("%s %d\n", (*ps).name, (*ps).price);//ps指向sb，*ps找到sb printf("%s %d\n", ps->name, ps->price);//结构体指针->结构体成员名 //->name找到了ps所指向的对象sb的name return 0; }
运行结果：
12. 表达式求值
表达式求值的顺序一部分是由操作符的优先级和结合性决定。
同样，有些表达式的操作数在求值的过程中可能需要转换为其他类型。
12.1 隐式类型转换
C的整型算术运算总是至少以缺省整型类型的精度来进行的。
为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。
整型提升的意义：
表达式的整型运算要在CPU的相应运算器件内执行，CPU内整型运算器(ALU)的操作数的字节长度
一般就是int的字节长度，同时也是CPU的通用寄存器的长度。
因此，即使两个char类型的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长 度。
通用CPU（general-purpose CPU）是难以直接实现两个8比特字节直接相加运算（虽然机器指令中可能有这种字节相加指令）。所以，表达式中各种长度可能小于int长度的整型值，都必须先转 换为int或unsigned int，然后才能送入CPU去执行运算。
如何进行整体提升呢？
整形提升是按照变量的数据类型的符号位来提升的
//负数的整形提升
char c1 = -1;
变量c1的二进制位(补码)中只有8个比特位：
1111111
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为1
提升之后的结果是：
11111111111111111111111111111111
//正数的整形提升
char c2 = 1;
变量c2的二进制位(补码)中只有8个比特位：
00000001
因为 char 为有符号的 char
所以整形提升的时候，高位补充符号位，即为0
提升之后的结果是：
00000000000000000000000000000001
//无符号整形提升，高位补0
//实例1 int main() { char a = 5; char b = 126; char c = a + b; printf("%d\n", c); return 0; }
b和c的值被提升为普通整型，然后再执行加法运算。
加法运算完成之后，结果将被截断，然后再存储于a中。
整形提升是按照变量的数据类型的符号位来提升的
那么上面代码的结果是不是131呢？接下来让我们来细细分析一番：
⭐️例1:
int main() { char a = 5;//截断 char b = 126;//截断 char c = a + b;//截断 //00000000000000000000000000000101 //00000101 - a //00000000000000000000000001111110 //01111110 - b //整型提升 //00000000000000000000000000000101-a //00000000000000000000000001111110-b //00000000000000000000000010000011 //10000011 - c printf("%d\n", c); //%d 十进制的方式打印有符号整数 //11111111111111111111111110000011 //11111111111111111111111110000010 //10000000000000000000000001111101 //-125 // return 0; }
配图解
⭐️例2:
int main() { char a = 0xb6; //10110110 // 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整形提升之后,变成了负数,所以表达式 a0xb6 , b0xb600 的结果是假,但是c不发生整形提升,则表
达式 c==0xb6000000 的结果是真.
需要注意的是无符号整型提升，高位直接补0
⭐️例3:
int main() { char c = 1; printf("%u\n", sizeof(c)); printf("%u\n", sizeof(+c)); printf("%u\n", sizeof(-c)); return 0; }
实例3中的,c只要参与表达式运算,就会发生整形提升,表达式 +c ,就会发生提升,所以 sizeof(+c) 是4个字
节.表达式 -c 也会发生整形提升,所以 sizeof(-c) 是4个字节,但是 sizeof© ,就是1个字节
12.2 算术转换
如果某个操作符的各个操作数属于不同的类型，那么除非其中一个操作数的转换为另一个操作数的类型，否则操作就无法进行。下面的层次体系称为寻常算术转换。
如果某个操作数的类型在上面这个列表中排名较低，那么首先要转换为另外一个操作数的类型后执行运
算。
警告：
但是算术转换要合理，要不然会有一些潜在的问题
float f = 3.14;
int num = f;//隐式转换，会有精度丢失
12.3 操作符的属性
复杂表达式的求值有三个影响的因素。
- 操作符的优先级
- 操作符的结合性
- 是否控制求值顺序。
两个相邻的操作符先执行哪个？取决于他们的优先级。如果两者的优先级相同，取决于他们的结合性。
操作符优先级
一些问题表达式
//表达式的求值部分由操作符的优先级决定。
//表达式1
ab + cd + e*f
注释：代码1在计算的时候，由于*比+的优先级高，只能保证，的计算是比+早，但是优先级并不
能决定第三个比第一个+早执行。
所以表达式的计算机顺序就可能是：
ab
cdab + cd
ef
ab + cd + ef或者：
ab
cdef
ab + cd
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;
}
表达式3在不同编译器中测试结果不同
//代码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(); 中我们只能通过操作符的优先级得知：先算乘法，再算减法。
函数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环境的结果：
VS2013环境的结果：
看看同样的代码产生了不同的结果，这是为什么？
简单看一下汇编代码.就可以分析清楚.这段代码中的第一个 + 在执行的时候，第三个++是否执行，这个是不确定的，因为依靠操作符的优先级和结合性是无法决定第一个 + 和第三个前置 ++ 的先后顺序。
总结：
我们写出的表达式如果不能通过操作符的属性确定唯一的计算路径，那这个表达式就是存在问题的。
希望以上内容对大家有所帮助👀，如有不足望指出🙏
