第7章运算符

🎯 本章学习目标

读完本章，你将能够：

✅ 说出 C++ 一级要求掌握的 7 类运算符及其作用
✅ 熟练掌握算术运算符，特别是整数除法截断和求余运算
✅ 能用 /10 和 %10 进行数位拆分（个位、十位、百位）
✅ 掌握 6 个关系运算符，知道 = 和 == 的本质区别
✅ 掌握 3 个逻辑运算符（&&、||、!），能写出复合条件
✅ 理解自增自减运算符，知道单独成行时前置后置效果相同
✅ 会用复合赋值运算符（+=、-=、*=、/=、%=）
✅ 会用三目运算符求两个数的较大值/较小值
✅ 记住运算符优先级的关键顺序，拿不准就加括号
✅ 综合运用运算符解决数位拆分、闰年判断、累加求和等经典问题

🗺️ 本章知识图谱

第7章 运算符
├── 一、运算符概述
│   └── 7大家族：算术、关系、逻辑、自增自减、复合赋值、三目、赋值
├── 二、算术运算符
│   ├── + - * / %
│   ├── 整数除法截断（5/2=2，不是2.5）
│   ├── 求余%（判断奇偶、取个位）
│   └── 优先级：括号→乘除求余→加减
├── 三、关系运算符
│   ├── > >= < <= == !=
│   ├── 结果是bool（true/false，cout输出1/0）
│   └── =赋值 vs ==比较（超级易错点）
├── 四、逻辑运算符
│   ├── &&与（并且，全真才真）
│   ├── ||或（或者，有真就真）
│   └── !非（取反）
├── 五、自增自减
│   ├── ++加1、--减1
│   └── 单独成行时前置后置效果相同
├── 六、复合赋值
│   └── += -= *= /= %=
├── 七、三目运算符
│   └── 条件?A:B（迷你if-else）
├── 八、优先级与结合性
│   └── 括号→单目→乘除→加减→关系→逻辑→赋值
└── 九、经典应用
    ├── 数位拆分（/10去位，%10取位）
    ├── 闰年判断
    ├── 成绩范围
    └── 累加求和

一、什么是运算符？

在数学里，我们用 +、−、×、÷ 让数字做运算；在 C++ 里，我们用**运算符（Operator）**告诉计算机"对数据做什么操作"。

打个比方 🎮：数据就像游戏里的小积木，运算符就是你的"操作指令"——放上一个 +，两块积木拼起来；放上一个 >，让两块积木比大小；放上一个 &&，要求两个条件同时成立。

被运算符"操作"的数据叫做操作数。比如 3 + 5 中，+ 是运算符，3 和 5 是操作数，3 + 5 整体叫做一个表达式，算出来的结果 8 叫做表达式的值。

一级考纲要求掌握的运算符家族：

类别	成员	作用	运算结果
算术运算符	`+ - * / %`	做数学计算	数字（int 或 double）
关系运算符	`> >= < <= == !=`	比大小、判相等	布尔值 `true` / `false`
逻辑运算符	`&& \|\| !`	组合多个条件	布尔值 `true` / `false`
自增自减	`++ --`	让变量 +1 / -1	改变变量的值
复合赋值	`+= -= *= /= %=`	赋值的简写	改变变量的值
三目运算符	`? :`	简单的二选一	依条件而定
赋值运算符	`=`	把值存进变量	——

记忆小窍门 🧠：算术管"算"，关系管"比"，逻辑管"连"，自增管"数数"，赋值管"存放"。

二、算术运算符：加减乘除的"升级版"

2.1 五个算术运算符全家福

运算符	含义	例子	结果	小提示
`+`	加法	`3 + 5`	`8`	和数学一样
`-`	减法	`7 - 2`	`5`	和数学一样
`*`	乘法	`3 * 4`	`12`	数学的 ×，键盘上用星号 `*`
`/`	除法	`6 / 2`	`3`	🔥 两个整数相除，结果还是整数！
`%`	求余（取余数）	`7 % 3`	`1`	分糖果剩下的那颗，只能用于整数

逐个来认识 👇

2.2 ⚠️🔥 整数除法：截断取整（一级第一大陷阱！）

先看一段代码，你能猜对输出吗？

cpp

#include <iostream>
using namespace std;

int main() {
    cout << 5 / 2 << endl;     // 2   ← 不是2.5！
    cout << 6 / 2 << endl;     // 3   ← 能整除，结果是整数3
    cout << 7 / 3 << endl;     // 2   ← 小数部分又被扔掉了
    cout << 10 / 4 << endl;    // 2
    return 0;
}

运行结果：

易错点 ⚠️： C++ 里两个整数相除，结果必须是整数。整数变量就像一个个"只能装整颗糖的小盒子"，装不下小数，于是计算机把小数部分直接扔掉（向 0 截断），这叫做截断取整。5 / 2 数学上等于 2.5，但 .5 装不下，扔掉，结果就是 2——不是四舍五入哦！
💡 牢记 C++ 的规则：6 / 2 得到整数 3，5 / 2 得到 2。只要除号两边都是整数，结果就一定是整数——这一点在一级考试里年年考，千万别按数学上的小数去算！

那想要小数结果怎么办？ 让除号两边至少有一边是小数就行：

cpp

cout << 5.0 / 2 << endl;    // 2.5   左边5.0是小数
cout << 5 / 2.0 << endl;    // 2.5   右边2.0是小数
cout << 5.0 / 2.0 << endl;  // 2.5

double x = 10, y = 4;       // double类型变量（第5章学的小数类型）
cout << x / y << endl;      // 2.5

高频考点 🔥： 注意一个超级隐蔽的坑——
cpp
double a = 5 / 2;
cout << a << endl;    // 输出 2，不是 2.5！
虽然 a 是 double 类型，但 = 右边的 5 / 2 是两个整数先相除，截断得到整数 2，再把 2 转成 2.0 存进 a。想得到 2.5，要写成 double a = 5.0 / 2;。判断题、读程序题最爱在这里设坑！

2.3 `%` 求余：不是百分号！

想象分糖果 🍬：7 颗糖果分给 3 个小朋友，每人 2 颗，手里还剩 1 颗。% 算的就是"剩下几颗"：

cpp

cout << 7 % 3 << endl;    // 1   （7 = 3×2 + 1，余数是1）
cout << 10 % 3 << endl;   // 1   （10 = 3×3 + 1）
cout << 9 % 3 << endl;    // 0   （正好分完，余数是0）
cout << 8 % 2 << endl;    // 0
cout << 5 % 2 << endl;    // 1

易错点 ⚠️： % 在 C++ 里是求余运算符，不是数学里的百分号！而且它只能用于整数（int），不能用于 double。% 和 / 是一对黄金搭档：7 / 3 = 2（每人分到几颗），7 % 3 = 1（剩下几颗）。

% 有两个一级必背的高频用途 🔥：

用途一：判断奇偶

一个数 % 2，余数为 0 是偶数，余数为 1 是奇数：

cpp

int n = 8;
cout << (n % 2 == 0) << endl;   // 1  成立：8是偶数
cout << (7 % 2 == 0) << endl;   // 0  不成立：7是奇数
cout << (7 % 2 == 1) << endl;   // 1  成立：7是奇数

用途二：取个位数字

一个整数 % 10，得到的就是它的个位（数位拆分例题在第九节细讲）：

cpp

cout << (123 % 10) << endl;   // 3  个位
cout << (56 % 10) << endl;    // 6

关于求余，还要记住两条小规律 🧩：

余数一定比除数小。比如 % 3 的余数只可能是 0、1、2，% 10 的余数只可能是 0~9——这就好比分糖果，剩下的糖不可能比分的人数还多；
被除数比除数小的时候，商是 0，余数就是它自己。比如 3 % 5 = 3（3 颗糖不够分给 5 个人，每人 0 颗，3 颗全剩下），配合整数除法 3 / 5 = 0，这也是读程序题偶尔出现的小考点。

2.4 算术运算顺序：先乘除取余，后加减

和数学课完全一样：

括号 ( ) 最优先（像排队时的 VIP 通道 🎫，先算括号里面的）；
再算 * / %（乘、除、求余，同一级从左往右）；
最后算 + -（加、减，同一级从左往右）。

cpp

cout << 2 + 3 * 4 << endl;      // 14   先算3×4=12，再算2+12
cout << (2 + 3) * 4 << endl;    // 20   括号优先：先算2+3=5，再算5×4
cout << 10 - 2 * 3 << endl;     // 4    先乘后减
cout << 2 + 10 % 3 << endl;     // 3    先求余：10%3=1，再加2
cout << 20 / 4 / 5 << endl;     // 1    同级从左到右：20/4=5，5/5=1

高频考点 🔥： 2 + 3 * 4 的结果是 14 不是 20！读程序题最爱考运算顺序。口诀背熟：括号 → 乘除求余 → 加减，同级从左到右。拿不准时，加括号永远是最保险的办法。

三、关系运算符：计算机的"小裁判"

关系运算符就像体育比赛的裁判 ⚖️，它不做计算，只回答一个问题："这个说法成立吗？"答案只有两个：true（真/成立） 或 false（假/不成立），它们属于第5章学过的 bool（布尔）类型。

运算符	含义	例子	结果
`==`	等于（两边一样吗？）	`3 == 3`	`true`
`!=`	不等于（感叹号表示"不"）	`3 != 4`	`true`
`>`	大于	`5 > 3`	`true`
`<`	小于	`5 < 3`	`false`
`>=`	大于等于	`5 >= 5`	`true`
`<=`	小于等于	`4 <= 3`	`false`

cpp

cout << (3 > 2) << endl;    // 1
cout << (3 < 2) << endl;    // 0
cout << (5 == 5) << endl;   // 1
cout << (5 != 6) << endl;   // 1
cout << (5 <= 5) << endl;   // 1   （"小于或等于"，等于也算成立）
cout << (5 < 5) << endl;    // 0   （5不小于5）

易错点 ⚠️： 注意输出结果是 1 和 0，不是 true 和 false！在 C++ 里，bool 量用 cout 输出时，默认 true 显示为 1、false 显示为 0。如果想让它显示英文单词，可以在输出前加一句 cout << boolalpha;（bool alpha = "用字母表示布尔值"）：
cpp
cout << boolalpha;
cout << (3 > 2) << endl;    // true
cout << (3 < 2) << endl;    // false
读程序题写输出时，先看程序里有没有 boolalpha：没有就写 1/0，有才写 true/false！

3.1 🔥 全场最重要：`=` 和 `==` 的区别

这是一级考试最高频的易错点，没有之一！两个符号长得像，意思完全不同：

符号	名称	作用	比喻
`=`	赋值运算符	把右边的值放进左边的变量盒子	`age = 8;`：把 8 放进 age 盒子
`==`	关系（比较）运算符	提问：左右两边相等吗？结果是 true/false	`age == 8`：age 盒子里装的是 8 吗？

打个比方 📦：= 是命令句——"把 8 放进盒子！"；== 是疑问句——"盒子里装的是 8 吗？"一个等号是发命令，两个等号是问问题。

cpp

int age = 8;           // 赋值：把8放进age（这是命令）
cout << age << endl;        // 8
cout << (age == 8) << endl; // 1  ← 比较：age等于8吗？是的！
cout << (age == 9) << endl; // 0  ← age是9吗？不是

易错点 ⚠️： 在 if 判断里写条件，必须用 ==，不能用 =！
cpp
if (a = 5) { ... }   // ❌ 大bug！这是"把5赋给a"，不是"判断a等于5"
if (a == 5) { ... }  // ✅ 正确：a等于5吗？
为什么 if (a = 5) 是 bug？因为 a = 5 这个赋值表达式的值就是 5，而 C++ 里非 0 的数都当作"真"，所以这个判断永远成立——程序会傻乎乎地一直执行"是"的分支。考试判断题和程序改错题经常在这里设坑，一定要擦亮眼！

四、逻辑运算符：把条件"连"起来

生活中我们常说复合条件："并且要考满分、或者周末、不能迟到"。C++ 用三个逻辑运算符表达这些关系，运算结果都是 bool（true/false）：

运算符	读法	含义	何时为 true
`&&`	与（并且）	两边都要成立	两边都为真，结果才为真
`\|\|`	或（或者）	两边有一个成立就行	只要一边为真，结果就是真
`!`	非（不是）	把结果翻个面	后面跟 false 时，结果为 true

💡 记忆小窍门：C++ 里用的是符号 && / || / !，不是英文单词。&& 像两扇都要打开的门（两个条件都要满足），! 像一根竖着的手指表示"不"。写法要记准，考试写错就编译不过！

4.1 `&&` 与：并且——两个条件都要满足

妈妈说 🎁："考 100 分并且乖乖听话，才有礼物。"两个条件缺一不可：

cpp

cout << (1 && 1) << endl;   // 1   两个条件都满足
cout << (1 && 0) << endl;   // 0   有一个不满足
cout << (0 && 0) << endl;   // 0

4.2 `||` 或：或者——满足一个就行

爸爸说 🎮："周六或者周日，可以打游戏。"只要是周末中的一天就行：

cpp

cout << (0 || 1) << endl;   // 1   有一个满足就行
cout << (1 || 0) << endl;   // 1
cout << (0 || 0) << endl;   // 0   两个都不满足才是0

4.3 `!` 非：不是——真变假，假变真

! 像一个"翻面器"🔄，专门唱反调：

cpp

cout << (!true) << endl;    // 0   真的变成假的
cout << (!false) << endl;   // 1   假的变成真的
cout << !(3 > 5) << endl;   // 1   3>5是假(0)，"不是假"就是真(1)

4.4 真值表（背下来，判断题直接秒杀）

A	B	`A && B`	`A \|\| B`	`!A`
真(1)	真(1)	真(1)	真(1)	假(0)
真(1)	假(0)	假(0)	真(1)	假(0)
假(0)	真(1)	假(0)	真(1)	真(1)
假(0)	假(0)	假(0)	假(0)	真(1)

口诀 🎵：&& 全真才真，|| 有真就真，! 真假颠倒。

4.5 实战例题：年龄范围与周末判断

例题 1： 判断年龄是否在 6 到 12 岁之间（含 6 和 12）——需要"年龄 ≥ 6"并且"年龄 ≤ 12"：

cpp

int age = 8;
cout << (age >= 6 && age <= 12) << endl;   // 1  8岁，两个条件都满足
cout << (age >= 6) << endl;                // 1
cout << (age <= 12) << endl;               // 1

易错点 ⚠️： && / || 两边必须写成完整的条件！不能偷懒写成 age >= 6 && <= 12（❌ 右边缺了主语，计算机看不懂）。正确写法是 age >= 6 && age <= 12，两边都把 age 写全。（C++ 不支持 6 <= age <= 12 这种数学里的连写，必须拆成两个条件用 && 连接！）

例题 2： 综合上阵：

cpp

cout << (3 > 2 && 4 > 5) << endl;   // 0  3>2为真，但4>5为假，&&要全真
cout << (3 > 2 || 4 > 5) << endl;   // 1  ||有真就真
cout << (!(5 > 3)) << endl;         // 0  5>3为真，!翻面为假

五、自增 `++` 与自减 `--`：数数小印章 🖊️

循环里我们经常要"数个数"：第 1 圈、第 2 圈、第 3 圈……每转一圈计数器加 1。C++ 给我们准备了两个超级方便的符号：

运算符	作用	等价写法	例子
`++`	变量的值 +1	`i = i + 1;`	`i++;` 后 i 多 1
`--`	变量的值 -1	`i = i - 1;`	`i--;` 后 i 少 1

cpp

int i = 0;
i++;                    // i 变成 1
cout << i << endl;      // 1
++i;                    // i 变成 2
cout << i << endl;      // 2
i--;                    // i 变成 1
cout << i << endl;      // 1

i++ 和 ++i 有什么区别？一个加号写在后面（后置），一个写在前面（前置）。

高频考点 🔥： 当 i++; 或 ++i; 单独成行时，两者效果完全一样，都是让 i 加 1。第6章学的 for 循环里，括号第三部分写的 i++ 就是最经典的用法：
cpp
for (int i = 1; i <= 5; i++) {   // i++：每循环一圈，计数器加1
    cout << i << " ";
}
// 输出：1 2 3 4 5
⚠️ 至于 ++ 写在表达式内部（如 a = i++; 和 a = ++i; 的区别），那是二级以后的进阶坑，一级只考单独成行的用法，大家记住"单独用，都一样"即可。

💡 为什么要用 ++：写 i++ 比写 i = i + 1 更短更清楚，而循环里几乎每次都要计数，所以 ++ 是 C++ 写循环最顺手的搭档。

六、复合赋值运算符：偷懒的小能手 😴

每次都写 a = a + 3; 是不是有点啰嗦？C++ 提供了"复合赋值"简写：把运算和赋值合二为一。

复合赋值	完整写法	含义
`a += 3;`	`a = a + 3;`	a 加 3
`a -= 3;`	`a = a - 3;`	a 减 3
`a *= 3;`	`a = a * 3;`	a 乘 3
`a /= 3;`	`a = a / 3;`	a 除以 3（整数除法！）
`a %= 3;`	`a = a % 3;`	a 求余 3

记忆方法：+= 就是"先 + 再 ="，符号顺序和读的顺序一样。

cpp

int a = 10;
a += 3;    cout << a << endl;   // 13  （10+3）
a -= 5;    cout << a << endl;   // 8   （13-5）
a *= 2;    cout << a << endl;   // 16  （8×2）
a /= 3;    cout << a << endl;   // 5   （16/3，整数除法截断！）
a %= 3;    cout << a << endl;   // 2   （5%3，余数2）

易错点 ⚠️： /= 和 %= 也遵守整数规则！a /= 3; 对于 int 变量来说是截断取整的除法，不是小数除法。累加求和的经典套路 sum += i;（每循环一次把 i 加进总和）在编程题里会反复用到，先混个脸熟。

七、三目运算符 `? :`：迷你小岔路 🛤️

如果一个判断特别简单——"条件成立选 A，不成立选 B"——懒得写一大段 if...else，就可以请出三目运算符（因为它有三个操作数，所以叫"三目"）：

条件 ? 表达式1 : 表达式2

读作："条件成立吗？成立就取表达式1，不成立就取表达式2。"就像走到一个岔路口 🛤️，左边一条路、右边一条路，根据条件二选一。

cpp

int a = 5, b = 8;
int max = a > b ? a : b;       // a>b成立吗？不成立，取b
cout << max << endl;           // 8

再看一个判断奇偶的小例子：

cpp

int n = 7;
cout << (n % 2 == 0 ? "偶数" : "奇数") << endl;   // 奇数

高频考点 🔥： 三目运算符是 if...else 的"迷你版"，考纲要求会读、会写简单形式。最经典的考法就是求两个数的较大值/较小值：
cpp
int max = a > b ? a : b;   // 较大值
int min = a < b ? a : b;   // 较小值
注意别把问号 ? 和冒号 : 写反、写漏。

八、运算符优先级：谁先算，谁后算？

一个表达式里出现好几种运算符时，计算顺序遵循下表（从高到低）：

优先级	运算符	说明
1（最高）	`( )`	括号，最优先
2	`! ++ --`	单目运算（非、自增、自减）
3	`* / %`	乘、除、求余
4	`+ -`	加、减
5	`> >= < <=`	大小关系比较
6	`== !=`	相等关系比较
7	`&&`	逻辑与
8	`\|\|`	逻辑或
9（最低）	`= += -= *= /= %=`	赋值类

口诀 🎵：括号最高 → 单目 → 乘除求余 → 加减 → 比大小 → 判等 → 与 → 或 → 赋值垫底。

cpp

cout << (2 + 3 * 4) << endl;              // 14  先乘后加
cout << ((2 + 3) * 4) << endl;            // 20  括号优先
cout << (3 + 5 > 2 * 2) << endl;          // 1   先算两边：8 > 4，成立
cout << (1 + 1 == 2 && 3 > 4) << endl;    // 0   先算术→再关系→最后&&：真&&假=假

高频考点 🔥： 优先级表不用死记硬背每一行，但要记住三个关键顺序：算术（先乘除后加减）→ 关系（先比大小后判等）→ 逻辑（先 && 后 ||），赋值永远最后。最保险的习惯是——拿不准就加括号，括号既能保证正确，又能让程序读起来清清楚楚。

九、典型例题精讲

9.1 数位拆分：`/` 和 `%` 的黄金搭档 🔥

这是一级编程题的超高频套路。记住两句话：

n % 10：取出 n 的个位数字（除 10 的余数就是个位）；
n / 10：去掉 n 的个位数字（整数除法，砍掉小尾巴）。

把一个三位数 123 拆成个位、十位、百位：

cpp

#include <iostream>
using namespace std;

int main() {
    int n = 123;
    int ge  = n % 10;         // 个位：123 % 10 = 3
    int shi = n / 10 % 10;    // 十位：123/10=12（砍掉个位），12%10=2
    int bai = n / 100;        // 百位：123/100=1（整数除法）
    cout << bai << " " << shi << " " << ge << endl;
    return 0;
}

运行结果：

1 2 3

拆解过程示意（像剥洋葱 🧅，一层层从个位剥起）：

操作	计算	得到
`n % 10`	123 ÷ 10 余 3	个位 3
`n / 10`	123 ÷ 10 截断	12（个位没了）
`n / 10 % 10`	12 % 10	十位 2
`n / 100`	123 ÷ 100 截断	百位 1

9.2 闰年判断：关系 + 逻辑的综合大戏 🔥

闰年规则（四年一闰，百年不闰，四百年再闰）：

能被 4 整除，但不能被 100 整除；或者
能被 400 整除。

翻译成 C++ 条件：

cpp

#include <iostream>
using namespace std;

int main() {
    int year = 2024;
    bool leap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);
    cout << year << (leap ? " 是闰年" : " 不是闰年") << endl;
    return 0;
}

运行结果：

2024 是闰年

验证几个年份 🔍：

年份	`%4==0`	`%100!=0`	`%400==0`	结果
2024	✅	✅	——	闰年（能被4整除且不被100整除）
2023	❌	——	❌	平年
2000	✅	❌（能被100整除）	✅	闰年（能被400整除）
1900	✅	❌	❌（1900%400=300）	平年（百年不闰，四百年才闰）

易错点 ⚠️： year % 4 == 0 里的 == 0 千万不能漏，也不能写成 = 0！"能被 4 整除"的数学翻译就是"除以 4 余数为 0"，即 year % 4 == 0。

9.3 成绩范围判断

cpp

#include <iostream>
using namespace std;

int main() {
    int score = 85;
    if (score >= 90 && score <= 100) {
        cout << "优秀" << endl;
    } else if (score >= 60 && score < 90) {
        cout << "及格" << endl;
    } else {
        cout << "不及格，继续加油" << endl;
    }

    // 三目运算符版及格判定
    cout << (score >= 60 ? "恭喜及格！" : "下次加油！") << endl;
    return 0;
}

运行结果：

及格
恭喜及格！

9.4 累加求和：`++` 与 `+=` 的循环大合作 🔥

求 1+2+3+…+100 的和，是循环结构里的经典题，正好把本章学的 i++ 和 sum += i 串起来用：

cpp

#include <iostream>
using namespace std;

int main() {
    int sum = 0;                  // 装总和的"大篮子"，开始是空的0
    for (int i = 1; i <= 100; i++) {
        sum += i;                 // 每次把 i 丢进篮子：sum = sum + i
    }
    cout << "1到100的和是：" << sum << endl;
    return 0;
}

运行结果：

1到100的和是：5050

过程可以这样脑补 🧺：i 像一个报数员，从 1 报到 100（每圈 i++ 加 1）；sum 像一个大篮子，每报一个数就用 sum += i 把它装进篮子，最后篮子里就是 5050。计数用 i++，累加用 sum += i——这两个搭档在第9章编程实战中还会反复出现。

十、代码大演练：把全部运算符跑一遍

cpp

#include <iostream>
using namespace std;

int main() {
    // ① 算术运算符
    cout << "--- 算术 ---" << endl;
    cout << 5 / 2 << endl;        // 2    整数除法：截断取整！
    cout << 5.0 / 2 << endl;      // 2.5  有一边是小数，得到小数
    cout << 7 % 3 << endl;        // 1    求余：分糖果剩1颗
    cout << 2 + 3 * 4 << endl;    // 14   先乘后加
    cout << (2 + 3) * 4 << endl;  // 20   括号最优先

    // ② 关系运算符
    cout << "--- 关系 ---" << endl;
    cout << (3 > 2) << endl;      // 1    成立输出1
    cout << (3 == 4) << endl;     // 0    注意是两个等号！

    // ③ 逻辑运算符
    cout << "--- 逻辑 ---" << endl;
    int age = 8;
    cout << (age >= 6 && age <= 12) << endl;  // 1  年龄在6~12之间
    cout << (3 > 2 || 4 > 5) << endl;         // 1  ||有真就真
    cout << !(3 > 2) << endl;                 // 0  真变假

    // ④ 自增与复合赋值
    cout << "--- 自增/复合赋值 ---" << endl;
    int i = 0;
    i++;                           // i = 1
    ++i;                           // i = 2（单独成行，前后置一样）
    cout << i << endl;             // 2
    i += 10;                       // i = i + 10 = 12
    cout << i << endl;             // 12

    // ⑤ 三目运算符
    cout << "--- 三目 ---" << endl;
    int a = 5, b = 8;
    cout << (a > b ? a : b) << endl;   // 8  取较大值

    return 0;
}

运行结果（已实际上机核对 ✅）：

--- 算术 ---
2
2.5
1
14
20
--- 关系 ---
1
0
--- 逻辑 ---
1
1
0
--- 自增/复合赋值 ---
2
12
--- 三目 ---
8

十一、📝 实战练习

练习题 1（程序阅读题）

题目： cout << 2 + 3 * 4 << endl; cout << 10 % 3 << endl; cout << 7 / 2 << endl; cout << 7.0 / 2 << endl; cout << 15 / 10 << endl; cout << 15 % 10 << endl;







<details>
<summary>🔑 点击查看答案与解析</summary>

**答案：**

14 1 3 3.5 1 5


**解析：**
- 第1行：先乘后加，`3*4=12`，`2+12=14`；
- 第2行：`10 = 3×3 + 1`，余数是 **1**；
- 第3行：两个整数相除，`7/2` 截断取整得 **3**（不是 3.5！）；
- 第4行：`7.0` 是小数，除法保留小数部分，得 **3.5**；
- 第5、6行：`15/10=1`（每人 1 颗），`15%10=5`（剩 5 颗）。





</details>

### 练习题 2（程序阅读题）

**题目：**
cout << (5 > 3) << endl;
cout << (5 == 5) << endl;
cout << (5 != 5) << endl;
cout << (3 > 2 && 4 > 5) << endl;
cout << (3 > 2 || 4 > 5) << endl;
cout << !(3 > 2) << endl;
int x = 7;
cout << (x % 2 == 0) << endl;
int k = 0;
k++;
k++;
cout << k << endl;
cout << (x > k ? x : k) << endl;

🔑 点击查看答案与解析

答案：

解析：

第1行：5 大于 3，成立 → 1；
第2行：5 等于 5，成立 → 1；
第3行：5 不等于 5？不成立 → 0；
第4行：3>2 为真，4>5 为假，&& 要全真 → 0；
第5行：|| 有一个真就真 → 1；
第6行：3>2 为真，! 翻面 → 0；
第7行：7 是奇数，7%2==0 不成立 → 0；
第8~9行：k 从 0 自增两次变成 2；
第10行：三目运算，x=7、k=2，7>2 成立取 x → 7。

练习题 3（判断题）

题目： 判断下面说法是否正确：

C++ 中 5 / 2 的结果是 2.5。（　）
double a = 5 / 2; 执行后，a 的值是 2.5。（　）
% 是求余运算符，只能用于整数，7 % 3 的结果是 1。（　）
if (a = 5) 是判断 a 是否等于 5 的正确写法。（　）
判断闰年可以写 (y%4==0 && y%100!=0) || y%400==0。（　）
i++; 和 ++i; 单独成行时，效果相同。（　）

🔑 点击查看答案与解析

答案：

❌（两个整数相除截断取整，结果是 2）
❌（5/2 先按整数除法得 2，再存入 a，a 是 2.0；应写 5.0/2）
✅
❌（判断相等要用 ==，应为 if (a == 5)；a = 5 是赋值，且非 0 永真）
✅
✅

练习题 4（单选题）

题目： 表达式 10 / 3 + 10 % 3 的结果是（）

A. 3　　B. 4　　C. 3.3　　D. 1

🔑 点击查看答案与解析

答案： B

解析： 先算除法和求余，再相加：

10 / 3 = 3（整数除法，截断取整）
10 % 3 = 1（求余，10 除以 3 余 1）
3 + 1 = 4

💡 记住：/ 和 % 优先级比 + 高，而且整数除法会直接砍掉小数部分。

练习题 5（单选题）

题目： 有代码 int x = 5; if (x = 0) cout << "A"; else cout << "B";，输出结果是（）

A. A　　B. B　　C. 编译报错　　D. 0

🔑 点击查看答案与解析

答案： B

解析： 这是经典的"等号陷阱"题。if (x = 0) 里面是一个等号的赋值，不是比较！

执行 x = 0，把 0 放进 x；
赋值表达式的值就是赋的值，也就是 0；
0 在 if 里被当作"假"，所以走 else，输出 B。

🔥 一级必考！ 记住：一个等号是"放进去"（赋值），两个等号是"比一比"（判断相等）。写 if 条件时，一定要检查是 = 还是 ==！

练习题 6（程序阅读题）

题目： 阅读以下程序，写出输出结果。

cpp

int a = 3;
int b = a++;
cout << a << " " << b << endl;

A. 3 3　　B. 4 3　　C. 3 4　　D. 4 4

🔑 点击查看答案与解析

答案： B

解析： 关键区别：

后置自增 a++：先取 a 的值用，再让 a 加 1
所以 b = a++ 的执行顺序是：
1. 先取 a 当前的值 3
2. 把 3 赋给 b（b 变成 3）
3. a 再加 1（a 变成 4）
最终 a = 4，b = 3，输出 4 3

💡 记忆口诀：后置++：先用后加（先把旧值拿走用，自己再涨）。如果是 ++a（前置），就是"先加后用"。

练习题 7（程序阅读题）

题目： 阅读以下程序，写出输出结果。

cpp

int x = 10;
x += 5;
x -= 3;
x *= 2;
cout << x << endl;

🔑 点击查看答案与解析

答案： 24

解析： 一步步算：

x = 10
x += 5 → x = x + 5 = 10 + 5 = 15
x -= 3 → x = x - 3 = 15 - 3 = 12
x *= 2 → x = x * 2 = 12 * 2 = 24

💡 复合赋值运算符的规则：a op= b 等价于 a = a op b（op 可以是 +、-、*、/、% 等）。

练习题 8（单选题）

题目： 有代码 int a = 5, b = 3; cout << (a > b ? a : b);，输出结果是（）

A. 5　　B. 3　　C. 1　　D. 0

🔑 点击查看答案与解析

答案： A

解析： 三目运算符 条件 ? 值1 : 值2 的规则：

条件为真 → 返回值1
条件为假 → 返回值2

这里 a > b 即 5 > 3 为真，所以返回 a 的值 5。

这段代码的意思是"取 a 和 b 中较大的那个"——三目运算符最经典的用法就是求两数的最大/最小值。

练习题 9（判断题）

题目： 判断以下说法是否正确。

表达式 (3 > 5) && (8 > 2) 的结果是假。（　）
逻辑与 && 中，如果左边已经是假，右边的表达式就不会执行了。（　）
!(5 > 3) 的结果是真。（　）
true || false 的结果是 true。（　）

🔑 点击查看答案与解析

答案：

✅（左边 3>5 是假，假 && 任何 = 假）
✅（这叫"短路求值"——左边已经能决定结果了，右边就偷懒不算了）
❌（5>3 是真，! 取反后是假）
✅（或运算，有一个真就是真）

🔥 短路求值是高频考点：&& 左边为假时右边不执行，|| 左边为真时右边不执行。考试里常考"右边的自增有没有生效"。

练习题 10（程序阅读题）

题目： 阅读以下程序，写出输出结果。

cpp

int x = 4;
int y = 2;
int z = x + y * 2;
x *= z / y;
cout << x << " " << y << " " << z << endl;

🔑 点击查看答案与解析

答案： 16 2 8

解析： 一步步来，注意优先级：

x = 4，y = 2
z = x + y * 2：先算乘 y*2 = 4，再加 x+4 = 8，所以 z = 8
x *= z / y：先算右边 z / y = 8 / 2 = 4，再 x *= 4 即 x = x * 4 = 4 * 4 = 16，所以 x = 16
y 始终没变，还是 2
最终输出：16 2 8

💡 遇到复杂表达式，按优先级拆成一步步算，千万不要跳步！优先级口诀：乘除取余 > 加减 > 关系 > 逻辑 > 三目 > 赋值。

十二、🧰 考场运算符自查清单

交卷前，花 30 秒用这份清单扫一眼自己的代码：

[ ] 题目要小数结果吗？两个整数相除会截断，该写 5.0/2 或 double 变量的地方写了吗？
[ ] 判断相等的地方，用的是两个等号 == 吗？（if 括号里出现单个 = 就是危险信号 🚨）
[ ] 求余 % 两边都是整数吗？奇偶判断写的是 n % 2 == 0（不是 n / 2 == 0！）
[ ] 逻辑与、或写的是 &&、|| 吗？（别写成英文单词 and、or，C++ 不认，会报错）
[ ] 复合条件两边写全了吗？age >= 6 && age <= 12，右边的 age 没偷懒漏掉吧？
[ ] 循环里计数写 i++、累加写 sum += i，循环结束后再输出结果？
[ ] 拿不准优先级的地方，都加括号了吗？

十三、📊 考点总结表

考点	重要程度	出题形式
🔥 整数除法截断取整（`5/2=2`），想要小数用 `5.0/2` 或 double	⭐⭐⭐⭐⭐	选择/判断/读程序
`double a = 5/2;` 得 2.0 的隐蔽陷阱	⭐⭐⭐⭐	判断/读程序
`%` 求余（不是百分号！只用于整数）	⭐⭐⭐⭐⭐	选择/读程序/编程
🔥 用 `%2` 判断奇偶、`%10` 取个位、`/10` 去个位	⭐⭐⭐⭐⭐	编程/读程序
运算顺序：括号→乘除求余→加减	⭐⭐⭐⭐⭐	读程序
关系运算结果是 bool，cout 默认输出 1/0	⭐⭐⭐⭐	读程序
🔥 `=` 赋值与 `==` 比较的区别（`if(a=5)` 是 bug）	⭐⭐⭐⭐⭐	判断/改错/编程
`&&` / `		`/`!` 的含义与真值表
逻辑两边写完整条件（`age>=6 && age<=12`）	⭐⭐⭐⭐	编程/改错
`i++` / `++i` 单独成行效果相同，循环计数常用	⭐⭐⭐⭐	读程序/编程
复合赋值 `+= -= *= /= %=`（`/=` 也是整数除法）	⭐⭐⭐	选择/读程序
三目运算符 `条件 ? A : B`（求较大值）	⭐⭐⭐⭐	选择/读程序
运算符优先级总表（拿不准加括号）	⭐⭐⭐⭐	读程序
数位拆分、闰年判断、成绩范围、累加求和四大综合应用	⭐⭐⭐⭐⭐	编程题

🔍 深度辨析：运算符优先级的"三层模型"

优先级表不用死记硬背 9 个等级，记住"三层模型"就能应对 90% 的题目：

第1层：算术运算（先算什么）
   括号 → 单目（!、++、--）→ 乘除求余 → 加减

第2层：关系运算（比大小）
   先比大小（>、>=、<、<=）→ 再判等（==、!=）

第3层：逻辑运算（连起来）
   非（!）→ 与（&&）→ 或（||）

最底层：赋值（=、+=、-= 等），永远最后算

解题步骤：遇到复杂表达式，按"先算术、再关系、最后逻辑"的顺序一步步化简。

比如 1 + 2 * 3 > 4 && 5 < 6：

先算算术：2*3=6，1+6=7 → 变成 7 > 4 && 5 < 6
再算关系：7>4=true，5<6=true → 变成 true && true
最后逻辑：true && true = true → 结果是 1

💡 保命技巧：实在拿不准优先级，加括号！括号既保证正确，又让代码清晰易读。阅卷老师看了也开心。

🧩 拓展（📚 超纲）：什么是"短路求值"？

逻辑运算符有一个有趣的特性——短路求值（Short-circuit Evaluation）：

对于 A && B：如果 A 已经是假的，那不管 B 是什么，整体肯定是假的。于是编译器直接跳过 B 不计算。
对于 A || B：如果 A 已经是真的，那不管 B 是什么，整体肯定是真的。于是编译器直接跳过 B 不计算。

打个比方 🎮：你要同时满足"写完作业并且打扫房间"才能玩游戏。如果作业没写完（A为假），不用看房间打没打扫，直接就不能玩了——这就是 && 的短路。

cpp

int a = 0;
bool result = (a != 0) && (10 / a > 2);
// 左边 a!=0 为假，右边 10/a 根本不会执行
// （如果真的执行了 10/0，程序就崩溃了）

📌 一级要求：知道有"短路求值"这个现象即可，不需要深入考代码阅读。二级阶段会有更详细的题目。

┌──────────────────────────────────────────────────────────────┐
│                  ⭐ 第7章必背速记卡（运算符）                    │
├──────────────────────────────────────────────────────────────┤
│  1. 算术：+ - * / %；整数除法截断（5/2=2），求余要整数         │
│  2. 想要小数结果：至少一边是小数（5.0/2=2.5）                 │
│  3. 陷阱：double a = 5/2 → a是2.0（先整数除法再存）           │
│  4. %用途：判断奇偶（%2）、取个位（%10）、去个位（/10）       │
│  5. 关系：> >= < <= == !=；结果是bool，cout默认输出1/0        │
│  6. =是赋值（放进去），==是比较（比一比）；if里写==才对       │
│  7. 逻辑：&&与（都成立才真）、||或（一个成立就真）、!非（取反）│
│  8. 真值表：&&全真才真，||有真就真，!真假颠倒                 │
│  9. 复合条件两边要写全：age>=6 && age<=12（右边age不能省）    │
│ 10. 自增++加1，自减--减1；单独成行前置后置一样               │
│ 11. 复合赋值：+= -= *= /= %=；/=对整数也是截断除法           │
│ 12. 三目：条件?A:B；常用：max=a>b?a:b；min=a<b?a:b         │
│ 13. 优先级：括号→单目→乘除→加减→关系→逻辑→赋值             │
│ 14. 拿不准就加括号，既正确又清晰                              │
│ 15. 数位拆分：%10取个位，/10去个位                           │
│ 16. 闰年：(y%4==0 && y%100!=0) || y%400==0                  │
│ 17. 累加：sum+=i；计数：count++                              │
└──────────────────────────────────────────────────────────────┘

📖 下章预告：第8章我们将深入学习 C++ 的输入输出与头文件——cin 怎么读入各种类型的数据、cout 怎么格式化输出、头文件到底是什么、为什么要写 using namespace std…… 掌握了输入输出，你的程序就能和用户"对话"了！

第7章 运算符 ​

🎯 本章学习目标 ​

🗺️ 本章知识图谱 ​

一、什么是运算符？ ​

二、算术运算符：加减乘除的"升级版" ​

2.1 五个算术运算符全家福 ​

2.2 ⚠️🔥 整数除法：截断取整（一级第一大陷阱！） ​

2.3 % 求余：不是百分号！ ​

2.4 算术运算顺序：先乘除取余，后加减 ​

三、关系运算符：计算机的"小裁判" ​

3.1 🔥 全场最重要：= 和 == 的区别 ​

四、逻辑运算符：把条件"连"起来 ​

4.1 && 与：并且——两个条件都要满足 ​

4.2 || 或：或者——满足一个就行 ​

4.3 ! 非：不是——真变假，假变真 ​

4.4 真值表（背下来，判断题直接秒杀） ​

4.5 实战例题：年龄范围与周末判断 ​

五、自增 ++ 与自减 --：数数小印章 🖊️ ​

六、复合赋值运算符：偷懒的小能手 😴 ​

七、三目运算符 ? :：迷你小岔路 🛤️ ​

八、运算符优先级：谁先算，谁后算？ ​

九、典型例题精讲 ​

9.1 数位拆分：/ 和 % 的黄金搭档 🔥 ​

9.2 闰年判断：关系 + 逻辑的综合大戏 🔥 ​

9.3 成绩范围判断 ​

9.4 累加求和：++ 与 += 的循环大合作 🔥 ​

十、代码大演练：把全部运算符跑一遍 ​

十一、📝 实战练习 ​

练习题 1（程序阅读题） ​

练习题 3（判断题） ​

练习题 4（单选题） ​

练习题 5（单选题） ​

练习题 6（程序阅读题） ​

练习题 7（程序阅读题） ​

练习题 8（单选题） ​

练习题 9（判断题） ​

练习题 10（程序阅读题） ​

十二、🧰 考场运算符自查清单 ​

十三、📊 考点总结表 ​

🔍 深度辨析：运算符优先级的"三层模型" ​

🧩 拓展（📚 超纲）：什么是"短路求值"？ ​

第7章运算符

🎯 本章学习目标

🗺️ 本章知识图谱

一、什么是运算符？

二、算术运算符：加减乘除的"升级版"

2.1 五个算术运算符全家福

2.2 ⚠️🔥 整数除法：截断取整（一级第一大陷阱！）

2.3 `%` 求余：不是百分号！

2.4 算术运算顺序：先乘除取余，后加减

三、关系运算符：计算机的"小裁判"

3.1 🔥 全场最重要：`=` 和 `==` 的区别

四、逻辑运算符：把条件"连"起来

4.1 `&&` 与：并且——两个条件都要满足

4.2 `||` 或：或者——满足一个就行

4.3 `!` 非：不是——真变假，假变真

4.4 真值表（背下来，判断题直接秒杀）

4.5 实战例题：年龄范围与周末判断

五、自增 `++` 与自减 `--`：数数小印章 🖊️

六、复合赋值运算符：偷懒的小能手 😴

七、三目运算符 `? :`：迷你小岔路 🛤️

八、运算符优先级：谁先算，谁后算？

九、典型例题精讲

9.1 数位拆分：`/` 和 `%` 的黄金搭档 🔥

9.2 闰年判断：关系 + 逻辑的综合大戏 🔥

9.3 成绩范围判断

9.4 累加求和：`++` 与 `+=` 的循环大合作 🔥

十、代码大演练：把全部运算符跑一遍

十一、📝 实战练习

练习题 1（程序阅读题）

练习题 3（判断题）

练习题 4（单选题）

练习题 5（单选题）

练习题 6（程序阅读题）

练习题 7（程序阅读题）

练习题 8（单选题）

练习题 9（判断题）

练习题 10（程序阅读题）

十二、🧰 考场运算符自查清单

十三、📊 考点总结表

🔍 深度辨析：运算符优先级的"三层模型"

🧩 拓展（📚 超纲）：什么是"短路求值"？