运算符是一种特殊的符号，用以用于数据的运算、赋值和比较等。
表达式指的是一组运算数、运算符的组合，表达式一定具有值，一个变量或一个常量就是一个表达式，变量、常量与运算符也可以组成复杂一些的表达式。
一：运算符分类
（1）按照操作数个数分类：
- 一元运算符（一目运算符）
- 二元运算符（二目运算符）
- 三元运算符（三目运算符）
（2） 按照功能分类：
- 算术运算符
- 赋值运算符
- 关系运算符
- 逻辑运算符
- 位运算符
二：算术运算符
算术运算符是对数值类型的变量进行运算的，在C程序中使用的非常多。
| 运算符 | 描述 | 操作数个数 | 组成的表达式的值 | 副作用 |
| + | 正号 | 1 | 操作数本身 | 无 |
| - | 负号 | 1 | 操作数符号取反 | 无 |
| + | 加号 | 2 | 两个操作数之和 | 无 |
| - | 减号 | 2 | 两个操作数之差 | 无 |
| * | 乘号 | 2 | 两个操作数之积 | 无 |
| / | 除号 | 2 | 两个操作数之商 | 无 |
| % | 取模（取余） | 2 | 两个操作数相除的余数 | 无 |
| ++ | 自增 | 1 | 操作数自增前或自增后的值 | 有 |
| - - | 自减 | 1 | 操作数自减前或自减后的值 | 有 |
//正号和负号
#include <stdio.h>
int main()
{
int x = 12;
int x1 = -x, x2 = +x;
int y = -67;
int y1 = -y, y2 = +y;
printf("x1=%d, x2=%d \n", x1, x2);
printf("y1=%d, y2=%d \n", y1, y2);
return 0;
}//加、减、乘、除
#include <stdio.h>
int main()
{
int a = 5 + 2.5;
printf("%d\n", a * a);
double b = 6 / 4;
printf("%f\n", b); // 输出 1.000000
double c = 6.0 / 4;
printf("%f\n", c); // 输出 1.500000
return 0;
}注意：整数之间做除法时，结果只保留整数部分而舍弃小数部分。
//取模（取余）
#include <stdio.h>
int main()
{
int res1 = 10 % 3;
printf("%d\n", res1);
int res2 = -10 % 3;
printf("%d\n", res2);
int res3 = 10 % -3;
printf("%d\n", res3);
int res4 = -10 % -3;
printf("%d\n", res4);
return 0;
}注意：运算结果的符号与被模数也就是第一个操作数相同。
自增和自减
- 自增、自减运算符可以写在操作数的前面也可以写在操作数后面，不论前面还是后面，对操作数的副作用是一致的。
- 自增、自减运算符在前在后，对于表达式的值是不同的。 如果运算符在前，表达式的值是操作数自增、自减之后的值；如果运算符在后，表达式的值是操作数自增、自减之前的值。
//自增和自减
#include <stdio.h>
int main()
{
int i1 = 10, i2 = 20;
int i = i1++;
printf("%d\n", i); // 10
printf("%d\n", i1); // 11
i = ++i1;
printf("%d\n", i); // 12
printf("%d\n", i1); // 12
i = i2--;
printf("%d\n", i); // 20
printf("%d\n", i2); // 19
i = --i2;
printf("%d\n", i); // 18
printf("%d\n", i2); // 18
return 0;
}三：关系运算符（比较运算符）
| 运算符 | 描述 | 操作数个数 | 表达式的值 | 副作用 |
| == | 相等 | 2 | 0 或 1 | 无 |
| != | 不等 | 2 | 0 或 1 | 无 |
| < | 小于 | 2 | 0 或 1 | 无 |
| > | 大于 | 2 | 0 或 1 | 无 |
| <= | 小于等于 | 2 | 0 或 1 | 无 |
| >= | 大于等于 | 2 | 0 或 1 | 无 |
#include <stdio.h>
int main()
{
int a = 8;
int b = 7;
printf("a>b的值：%d \n", a > b);
printf("a>=b的值：%d \n", a >= b);
printf("a<b的值：%d \n", a < b);
printf("a<=b的值：%d \n", a <= b);
printf("a==b的值：%d \n", a == b);
printf("a!=b的值：%d \n", a != b);
return 0;;
}四：逻辑运算符
| 运算符 | 描述 | 操作数个数 | 表达式的值 | 副作用 |
| && | 逻辑与 | 2 | 0 或 1 | 无 |
| || | 逻辑或 | 2 | 0 或 1 | 无 |
| ! | 逻辑非 | 1 | 0 或 1 | 无 |
（1）：逻辑与 &&
如果两个操作数都为真（非零），那么表达式的值为真，否则为假。
如果第一个操作数为假，第二个操作数没有计算的必要了，这种现象称为短路现象。
#include <stdio.h>
int main()
{
double score = 70; // 成绩
if (score >= 60 && score <= 80)
{
printf("ok1 \n");
}
else
{
printf("ok2 \n");
}
int a = 10, b = 99;
// 短路现象
if (a < 2 && ++b > 99)
{
printf("ok100");
}
printf("b=%d\n", b);
return 0;
}（2）：逻辑或 ||
只要有一个操作数为真，表达式的值就为真；两个操作数都为假，表达式的值为假。
如果第一个操作数为真，第二个操作数没有计算的必要了，这种现象称为短路现象。
#include <stdio.h>
int main()
{
double score = 70;
if (score >= 70 || score <= 80)
{
printf("ok1 \n");
}
else
{
printf("ok2 \n");
}
int a = 10, b = 99;
// 短路现象
if (a > 5 || b++ > 100)
{ //
printf("ok100 \n");
}
printf("b=%d\n", b);
return 0;
}（3）：逻辑非
操作数状态取反作为表达式的值。
#include <stdio.h>
int main()
{
int score = 100;
int res = score > 99;
if (res)
{
printf("hello, tom \n");
}
if (!res)
{
printf("hello,jack \n");
}
return 0;
}五：赋值运算符
| 运算符 | 描述 | 操作数个数 | 表达式的值 | 副作用 |
| = | 赋值 | 2 | 左边操作数的值 | 有 |
| += | 相加赋值 | 2 | 左边操作数的值 | 有 |
| -= | 相减赋值 | 2 | 左边操作数的值 | 有 |
| *= | 相乘赋值 | 2 | 左边操作数的值 | 有 |
| /= | 相除赋值 | 2 | 左边操作数的值 | 有 |
| %= | 取余赋值 | 2 | 左边操作数的值 | 有 |
| <<= | 左移赋值 | 2 | 左边操作数的值 | 有 |
| >>= | 右移赋值 | 2 | 左边操作数的值 | 有 |
| &= | 按位与赋值 | 2 | 左边操作数的值 | 有 |
| ^= | 按位异或赋值 | 2 | 左边操作数的值 | 有 |
| |= | 按位或赋值 | 2 | 左边操作数的值 | 有 |
- 赋值运算符的第一个操作数（左值）必须是变量的形式，第二个操作数可以是任何形式的表达式。
- 赋值运算符的副作用针对第一个操作数。
#include <stdio.h>
int main()
{
int a = 10, b = 20, c = 30;
c += 3; // 等价于 c = c + 3; 计算后c的值变为33
c += b; // 等价于 c = c + b; 计算后c的值变为53
a += 1.7; // 等价于 a = a + 1.7 计算后a的值变为11
printf("a=%d b=%d c=%d", a, b, c);
return 0;
}六：位运算符
| 运算符 | 描述 | 操作数个数 | 副作用 |
| & | 按位与 | 2 | 无 |
| | | 按位或 | 2 | 无 |
| ^ | 按位异或 | 2 | 无 |
| ~ | 按位取反 | 1 | 无 |
| << | 按位左移 | 2 | 无 |
| >> | 按位右移 | 2 | 无 |
注意：操作数进行位运算的时候，以它的补码形式进行运算。
（1）：按位与、按位或、按位异或
#include <stdio.h>
int main()
{
int a = 17;
int b = -12;
printf("a&b=%d\n", a & b); // a&b=16
printf("a|b=%d\n", a | b); // a|b=-11
printf("a^b=%d\n", a ^ b); // a^b=-27
return 0;
}（2）：按位取反
#include <stdio.h>
int main()
{
int a = 17;
int b = -12;
// 按位非
printf("~a=%d\n", ~a);
printf("~b=%d\n", ~b);
return 0;
}（3）：按位左移、按位右移
#include <stdio.h>
int main()
{
int a = 17;
int b = -12;
// 按位左移
printf("a<<2=%d\n", a << 2); // a<<2=68
printf("b<<2=%d\n", b << 2); // b<<2=-48
// 按位右移
printf("a>>3=%d\n", a >> 3); // a>>3=2
printf("b>>3=%d\n", b >> 3); // b>>3=-2
return 0;
}七：三元运算符
基本语法：
条件表达式? 表达式1: 表达式2；
如果条件表达式为非0（真），整个表达式的值是表达式1；
如果条件表达式为0（假），整个表达式的值是表达式2；
#include <stdio.h>
int main()
{
int a = 10;
int b = 99;
int res = a > b ? a++ : b--;
int n1 = a > b ? 1.1 : 1.2;
printf("a=%d \n", a);
printf("b=%d \n", b);
printf("res=%d \n", res);
return 0;
}- 计算两个数的最大值（a , b）
#include <stdio.h>
int main()
{
int a = 10;
int b = 100;
int max = a > b ? a : b;
printf("a和b中最大的数字：%d", max);
return 0;
}2.计算三个数的最大值
#include <stdio.h>
int main()
{
int a = 10;
int b = 100;
int c = 199;
// int max1 = a>b ? a : b;
// int max2 = max1>c ? max1:c;
int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
printf("a、b、c中最大的数字：%d", max);
return 0;
}八：运算符优先级
| 优先级 | 运算符 | 名称或含义 | 结合方向 |
| 1 | [] | 数组下标 | 左到右 |
| () | 圆括号 | ||
| . | 成员选择（对象） | ||
| -> | 成员选择（指针） | ||
| 2 | - | 负号运算符 | 右到左 |
| （类型） | 强制类型转换 | ||
| ++ | 自增运算符 | ||
| -- | 自减运算符 | ||
| * | 取值运算符 | ||
| & | 取地址运算符 | ||
| ! | 逻辑非运算符 | ||
| ~ | 按位取反运算符 | ||
| sizeof | 长度运算符 | ||
| 3 | / | 除 | 左到右 |
| * | 乘 | ||
| % | 余数（取模） | ||
| 4 | + | 加 | 左到右 |
| - | 减 | ||
| 5 | << | 左移 | 左到右 |
| >> | 右移 | ||
| 6 | > | 大于 | 左到右 |
| >= | 大于等于 | ||
| < | 小于 | ||
| <= | 小于等于 | ||
| 7 | == | 等于 | 左到右 |
| != | 不等于 | ||
| 8 | & | 按位与 | 左到右 |
| 9 | ^ | 按位异或 | 左到右 |
| 10 | | | 按位或 | 左到右 |
| 11 | && | 逻辑与 | 左到右 |
| 12 | || | 逻辑或 | 左到右 |
| 13 | ?: | 条件运算符 | 右到左 |
| 14 | = | 赋值运算符 | 右到左 |
| /= | 除后赋值 | ||
| *= | 乘后赋值 | ||
| %= | 取模后赋值 | ||
| += | 加后赋值 | ||
| -= | 减后赋值 | ||
| <<= | 左移后赋值 | ||
| >>= | 右移后赋值 | ||
| &= | 按位与后赋值 | ||
| ^= | 按位异或后赋值 | ||
| |= | 按位或后赋值 | ||
| 15 | , | 逗号运算符 | 左到右 |
总结：
- 不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，尽量使用小括号来控制表达式的执行顺序。
- 不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则把它分成几步来完成。
- 运算符优先级不用刻意地去记忆，总体上：一元运算符 > 算术运算符 > 关系运算符 > 逻辑运算符 > 三元运算符 > 赋值运算符。
本章的内容就到这里。
关注我一起成为嵌入式大佬。
5524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
