目录
一、算术运算符
用于处理四则运算
（1）二元算术运算符（操作两个数）
1. 加法运算符（+）
含义：计算两个数的和
语法：
a + b示例：
int sum = 5 + 3; // 结果：8
double sum2 = 2.5 + 1.3; // 结果：3.8 - 注意：支持整数、浮点数混合运算（如
5 + 3.2 → 8.2）。
2. 减法运算符（-）
含义：计算两个数的差（
a - b）语法：
a - b示例：
int diff = 10 - 3; // 结果：7
double diff2 = 5.8 - 2.1; // 结果：3.7 - 注意：结果符号由被减数和减数的大小关系决定（如
5 - 8 → -3）。
3. 乘法运算符（*）
- 含义：计算两个数的乘积
- 语法：
a * b - 示例：
int product = 4 * 5; // 结果：20
double product2 = 2.5 * 3.0; // 结果：7.5 - 注意：整数相乘结果为整数，浮点数相乘结果为浮点数（如
2 * 2.5 → 5.0）。
4. 除法运算符（/）
- 含义：计算两个数的商（
a ÷ b） - 语法：
a / b - 示例：
int result1 = 10 / 3; // 结果：3（整数除法截断小数）
double result2 = 10.0 / 3.0; // 结果：3.333...（浮点数保留小数） - 注意：
- 整数除法：结果截断小数（如
10 / 3 → 3）。 - 浮点数除法：需至少一个操作数为浮点数（如
10.0 / 3 → 3.333...）。 - 除数不能为 0（否则运行时错误）。
- 整数除法：结果截断小数（如
5. 取模运算符（%）
- 含义：计算整数除法的余数
- 语法：
a % b - 示例：
int remainder = 10 % 3; // 结果：1（10 ÷ 3 余 1）
int remainder2 = 10 % -3; // 结果：1（余数符号与被除数相同） - 注意：
- 仅支持整数类型（
int,long等），不支持浮点数（如10.5 % 3会报错）。 - 除数不能为 0。
- 余数符号与被除数相同（如
-10 % 3 → -1）。
- 仅支持整数类型（
（2）一元算术运算符（操作一个数）
1. 正号运算符（+）
- 含义：显式标记正数（通常可省略）
- 语法：
+a - 示例：
int x = +5; // 等价于 int x = 5; - 注意：优先级高于乘除（如
+5 * 2 → 10）。
2. 负号运算符（-）
- 含义：对操作数取反（正→负，负→正）
- 语法：
-a - 示例：
int x = -5; // x = -5
int y = -(-5); // y = 5 - 注意：优先级高于乘除（如
-5 * 2 → -10）。
3. 前置递增运算符（++a）
- 含义：先将变量加 1，再返回变量的新值
- 语法：
++a - 示例：
int a = 2;
int b = ++a; // 执行顺序：1. a=a+1 → a=3；2. b=a → b=3
// 最终：a=3, b=3 4. 后置递增运算符（a++）
- 含义：先返回变量的当前值，再将变量加 1
- 语法：
a++ - 示例：
int a = 2;
int b = a++; // 执行顺序：1. b=a → b=2；2. a=a+1 → a=3
// 最终：a=3, b=2 5. 前置递减运算符（--a）
- 含义：先将变量减 1，再返回变量的新值
- 语法：
--a - 示例：
int a = 2;
int b = --a; // 执行顺序：1. a=a-1 → a=1；2. b=a → b=1
// 最终：a=1, b=1 6. 后置递减运算符（a--）
- 含义：先返回变量的当前值，再将变量减 1
- 语法：
a-- - 示例：
int a = 2;
int b = a--; // 执行顺序：1. b=a → b=2；2. a=a-1 → a=1
// 最终：a=1, b=2 （3）关键注意事项
除法的特殊性：
- 整数除法（如
10 / 3）会截断小数，结果为整数。 - 浮点数除法需至少一个操作数为浮点数（如
10.0 / 3）。
- 整数除法（如
取模运算的限制：
- 仅支持整数类型，不支持浮点数。
- 余数符号与被除数相同（如
-10 % 3 → -1，10 % -3 → 1）。
递增 / 递减运算符的区别：
- 前置（
++a/--a）：先修改变量，再使用新值。 - 后置（
a++/a--）：先使用当前值，再修改变量。
- 前置（
运算符优先级：
- 一元运算符（
+,-,++,--）优先级高于二元运算符（+,-,*,/,%）。 - 乘除取模（
*,/,%）优先级高于加减（+,-）。 - 示例：
2 + 3 * 4 → 2 + 12 → 14（先乘后加）。
- 一元运算符（
（4）综合例题
例题 1：整数与浮点数除法对比
#include <iostream>
using namespace std;
int main() {
int a = 10, b = 3;
double c = 10.0, d = 3.0;
cout << "整数除法：" << a / b << endl; // 输出：3
cout << "浮点数除法：" << c / d << endl; // 输出：3.333...
return 0;
} 例题 2：前置与后置递增的差异
#include <iostream>
using namespace std;
int main() {
int a = 5;
int b = ++a; // 先a=a+1（a=6），再b=a（b=6）
int c = a++; // 先c=a（c=6），再a=a+1（a=7）
cout << "a=" << a << ", b=" << b << ", c=" << c << endl;
// 输出：a=7, b=6, c=6
return 0;
} 例题 3：取模运算判断奇偶
#include <iostream>
using namespace std;
int main() {
int num = 7;
if (num % 2 == 0) {
cout << num << " 是偶数" << endl;
} else {
cout << num << " 是奇数" << endl;
}
return 0;
} 二、赋值运算符
用于将表达式的值赋给变量
1. 基本赋值运算符 =
- 含义：最基础的赋值操作，把右侧表达式计算结果，赋予左侧变量 。
- 作用：用于给变量初始化或更新变量值，是数据存储、传递的基础操作 。
- 语法格式：
变量 = 表达式;，要求左侧必须是可修改的左值（如普通变量，不能是常量、表达式结果），右侧是能计算出值的表达式（常量、变量、运算组合等）。 - 示例：
int a, b;
a = 5; // 把常量 5 赋值给变量 a，执行后 a 的值为 5
b = a + 3; // 先计算 a + 3（值为 8 ），再把结果赋值给 b，执行后 b 的值为 8 2. 复合赋值运算符
（1）加等于运算符 +=
- 含义：将变量当前值与右侧表达式结果相加，把新结果再赋给该变量，等价于
变量 = 变量 + 表达式;。 - 作用：简化变量自身做加法后再赋值的代码，让累加操作更简洁 。
- 语法格式：
变量 += 表达式;，左侧是变量，右侧是合法表达式，运算时先算右侧，再和变量原值相加更新变量 。 - 示例：
int a = 3;
a += 2; // 等价于 a = a + 2 ，执行后 a 的值变为 5
a += (1 + 1); // 等价于 a = a + (1 + 1) ，先算右侧得 2 ，a 原本是 5 ，执行后 a 变为 7 （2）减等于运算符 -=
- 含义：用变量当前值减去右侧表达式结果，把差重新赋给变量，等价于
变量 = 变量 - 表达式;。 - 作用：简化变量自身做减法后赋值的代码，方便实现递减逻辑 。
- 语法格式：
变量 -= 表达式;，执行逻辑是先算右侧表达式，再用变量原值减它，更新变量 。 - 示例：
int b = 10;
b -= 3; // 等价于 b = b - 3 ，执行后 b 变为 7
b -= (2 * 1); // 等价于 b = b - (2 * 1) ，先算右侧得 2 ，b 原本 7 ，执行后变为 5 （3）乘等于运算符 *=
- 含义：把变量当前值与右侧表达式结果相乘，乘积赋回给变量，等价于
变量 = 变量 * 表达式;。 - 作用：简化变量自身做乘法后赋值的操作，常用于倍数放大等场景 。
- 语法格式：
变量 *= 表达式;，运算时先计算右侧，再和变量原值相乘更新变量 。 - 示例：
int c = 4;
c *= 2; // 等价于 c = c * 2 ，执行后 c 变为 8
c *= (1 + 1); // 等价于 c = c * (1 + 1) ，右侧算得 2 ，c 原本 8 ，执行后变为 16 （4）除等于运算符 /=
- 含义：用变量当前值除以右侧表达式结果（整数除法时会做取整，浮点数除法按数学规则），商赋回给变量，等价于
变量 = 变量 / 表达式;，要注意除数不能为 0 。 - 作用：简化变量自身做除法后赋值的代码，用于数值按比例缩小等场景 。
- 语法格式：
变量 /= 表达式;，执行时先算右侧，再用变量原值除以它（需保证除数非 0 ）更新变量 。 - 示例：
int d = 8;
d /= 2; // 等价于 d = d / 2 ，执行后 d 变为 4
// d /= 0; // 错误！除数不能为 0 ，会导致程序运行时错误
float e = 10.5f;
e /= 2; // 等价于 e = e / 2 ，执行后 e 变为 5.25 （5）模等于运算符 %=
- 含义：计算变量当前值对右侧表达式结果取模（求余数，要求两侧均为整数，且除数非 0 ），余数赋回给变量，等价于
变量 = 变量 % 表达式;。 - 作用：常用于循环计数、判断数值奇偶性（和 2 取模）等场景，简化取余后赋值操作 。
- 语法格式：
变量 %= 表达式;，执行时先算右侧（需是非 0 整数），再用变量原值对其取模更新变量 。 - 示例：
int f = 7;
f %= 3; // 等价于 f = f % 3 ，7 除以 3 余数是 1 ，执行后 f 变为 1
// f %= 0; // 错误！取模运算除数不能为 0
int g = 5;
g %= 2; // 结果为 1 ，可用于判断 g 原本是奇数（结果非 0 为奇数，0 为偶数 ）三、比较运算符
用于表达式的比较，并返回一个真值或假值
1. ==（相等于）
- 含义：判断两个操作数的值是否相等。
- 作用：常用于条件判断，比如判断用户输入是否符合预期值、比较变量间数值是否一致等场景。
- 语法格式：
操作数1 == 操作数2，操作数可以是变量、常量、表达式等，结果为布尔类型，相等时为true（代码里常表现为1），不相等时为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 5, b = 5;
bool result = (a == b);
cout << "a == b 的结果是：" << result << endl;
return 0;
}运行结果：
a == b 的结果是：1，因为a和b数值相等，==比较后返回true，输出1。
2. !=（不等于）
- 含义：判断两个操作数的值是否不相等。
- 作用：和
==相反，用于筛选出数值不同的情况，像判断用户输入是否为特定值之外的内容等。 - 语法格式：
操作数1 != 操作数2，结果为布尔类型，不相等时为true（代码里常表现为1），相等时为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 5, b = 3;
bool result = (a != b);
cout << "a != b 的结果是：" << result << endl;
return 0;
}运行结果：
a != b 的结果是：1，由于a和b数值不同，!=比较后返回true，输出1。
3. <（小于）
- 含义：判断左边操作数的值是否小于右边操作数的值。
- 作用：常用于数值大小比较，比如找出一组数中的较小值、判断数据是否在某个区间下限之外等场景。
- 语法格式：
操作数1 < 操作数2，结果为布尔类型，左边小于右边时为true（代码里常表现为1），否则为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 3, b = 5;
bool result = (a < b);
cout << "a < b 的结果是：" << result << endl;
return 0;
}运行结果：
a < b 的结果是：1，因为3小于5，<比较后返回true，输出1。
4. >（大于）
- 含义：判断左边操作数的值是否大于右边操作数的值。
- 作用：和
<对应，用于找出较大值、判断数据是否超出区间上限等情况。 - 语法格式：
操作数1 > 操作数2，结果为布尔类型，左边大于右边时为true（代码里常表现为1），否则为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 5, b = 3;
bool result = (a > b);
cout << "a > b 的结果是：" << result << endl;
return 0;
}运行结果：
a > b 的结果是：1，因5大于3，>比较后返回true，输出1。
5. <=（小于等于）
- 含义：判断左边操作数的值是否小于或等于右边操作数的值。
- 作用：在判断数值范围时更宽泛，比如判断数据是否不超过某个上限值等场景。
- 语法格式：
操作数1 <= 操作数2，结果为布尔类型，左边小于或等于右边时为true（代码里常表现为1），否则为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 3, b = 3;
bool result = (a <= b);
cout << "a <= b 的结果是：" << result << endl;
return 0;
}运行结果：
a <= b 的结果是：1，因为a等于b，满足 “小于等于”，<=比较后返回true，输出1。
6. >=（大于等于）
- 含义：判断左边操作数的值是否大于或等于右边操作数的值。
- 作用：用于判断数值不低于某个下限等情况，丰富条件判断逻辑。
- 语法格式：
操作数1 >= 操作数2，结果为布尔类型，左边大于或等于右边时为true（代码里常表现为1），否则为false（代码里常表现为0）。 - 例题：
#include <iostream>
using namespace std;
int main() {
int a = 5, b = 5;
bool result = (a >= b);
cout << "a >= b 的结果是：" << result << endl;
return 0;
}运行结果：
a >= b 的结果是：1，由于a等于b，符合 “大于等于”，>=比较后返回true，输出1。
四、逻辑运算符
用于根据表达式的值返回真值或假值
1. 逻辑非（!）
- 含义：对操作数的布尔值取反。
- 作用：用于反转一个条件的真假状态，常配合其他条件判断使用。
- 语法格式：
!操作数，操作数通常是布尔类型（bool）或可隐式转换为布尔值的表达式（如整数、指针等，非 0 值视为true，0 视为false）。 - 示例：
#include <iostream>
using namespace std;
int main() {
bool a = true;
bool result = !a;
cout << "!a 的结果：" << (result ? "true" : "false") << endl;
int b = 5;
bool result2 = !b;
cout << "!b 的结果（b 非 0 视为 true，取反后为 false）："
<< (result2 ? "true" : "false") << endl;
return 0;
}输出：
!a 的结果：false
!b 的结果（b 非 0 视为 true，取反后为 false）：false
2. 逻辑与（&&）
- 含义：判断多个条件是否同时成立，类似 “并且” 的逻辑。
- 作用：当需要多个条件都满足时执行某段代码，就用逻辑与连接这些条件；同时具有 “短路求值” 特性，若左侧表达式为
false，右侧表达式不会执行（因为整体已确定为false）。 - 语法格式：
操作数1 && 操作数2，操作数可以是布尔值、布尔表达式等 。 - 示例：
#include <iostream>
using namespace std;
int main() {
int num = 10;
// 判断 num 大于 5 且小于 15
if (num > 5 && num < 15) {
cout << "num 同时满足大于 5 和小于 15 的条件" << endl;
}
// 短路求值示例
int x = 0;
// 左侧 x == 0 为 true，继续判断右侧，x 自增为 1
if (x == 0 && ++x > 0) {
cout << "x 经过逻辑与运算后的值：" << x << endl;
}
return 0;
}输出：
num 同时满足大于 5 和小于 15 的条件
x 经过逻辑与运算后的值：1
3. 逻辑或（||）
- 含义：判断多个条件中是否至少有一个成立，类似 “或者” 的逻辑。
- 作用：只要有一个条件满足就执行对应代码；也有 “短路求值” 特性，若左侧表达式为
true，右侧表达式不会执行（因为整体已确定为true）。 - 语法格式：
操作数1 || 操作数2，操作数可以是布尔值、布尔表达式等 。 - 示例：
#include <iostream>
using namespace std;
int main() {
int score = 85;
// 判断 score 大于 90 或者小于 60（这里演示只要一个满足）
if (score > 90 || score < 60) {
cout << "成绩处于优秀或不及格区间" << endl;
} else {
cout << "成绩处于中等区间" << endl;
}
// 短路求值示例
int y = 10;
// 左侧 y == 10 为 true，右侧 y-- 不会执行，y 仍为 10
if (y == 10 || y-- < 20) {
cout << "y 经过逻辑或运算后的值：" << y << endl;
}
return 0;
}输出：
成绩处于中等区间
y 经过逻辑或运算后的值：10