Appearance
第6章 三大基本结构
🎯 本章学习目标
读完本章，你将能够：
- ✅ 说出程序的三大基本结构（顺序、分支、循环）及其作用
- ✅ 熟练使用 if、if...else、if...else if...else 三种分支结构
- ✅ 掌握比较运算符（==、!=、>、<、>=、<=）和逻辑运算符（&&、||、!）
- ✅ 理解 switch 语句的用法，知道 case 穿透现象和 break 的作用
- ✅ 熟练使用 for 循环，能准确判断循环次数，避开"差一"陷阱
- ✅ 熟练使用 while 循环，掌握"起点、条件、变化"三件套
- ✅ 了解 do...while 循环，知道它和 while 的区别
- ✅ 区分 break 和 continue 的作用（跳出整个循环 vs 跳过本次）
- ✅ 掌握累加器套路，能写出 1 到 N 求和等经典程序
- ✅ 综合运用三大结构解决简单编程题
🗺️ 本章知识图谱
第6章 三大基本结构
├── 一、三大基本结构概述
│ ├── 顺序结构：从上到下（默认）
│ ├── 分支结构：if/else/switch（看情况办事）
│ └── 循环结构：for/while/do-while（重复劳动）
├── 二、顺序结构
│ ├── 从上到下依次执行
│ ├── 变量先赋值再使用
│ └── 交换变量：第三个盒子做中转
├── 三、分支结构
│ ├── if单分支：条件成立才做
│ ├── if...else：二选一
│ ├── if...else if...else：多选一（命中即停）
│ ├── switch：等于哪个固定值（case穿透/break）
│ ├── 三目运算符 ?:（了解）
│ └── 比较与逻辑运算符
├── 四、循环结构
│ ├── for循环：知道次数时用（三部分两个分号）
│ ├── while循环：次数不确定时用（三件套）
│ ├── do...while：先做一次再说（结尾分号）
│ ├── break：跳出整个循环
│ └── continue：跳过本次
└── 五、综合应用：循环+分支+顺序一、程序的三大基本结构
想象你早上起床上学：
- 先起床，再穿衣，再洗漱——一步一步按顺序来；
- 走到路口，看红绿灯：绿灯走斑马线，红灯等一等——遇到情况做选择；
- 体育课绕操场跑 3 圈，同样的动作重复做 3 遍——反复执行。
写程序也是这三种走法，它们有一个正式的名字——三大基本结构：
| 基本结构 | 生活比喻 | 作用 | C++ 关键字 |
|---|---|---|---|
| 顺序结构 | 读绘本：从第一页一行一行往下读 | 代码从上到下依次执行 | （默认就是，无需关键字） |
| 分支结构 | 路口选方向：走左边还是走右边 | 条件成立走这边，不成立走那边 | if、else、switch、case、default |
| 循环结构 | 跑圈：一圈一圈重复 | 同一段代码反复执行多次 | for、while、do |
💡 本章代码里的
#include <iostream>、cin、cout是输入输出的"固定套路"，第8章会专门细讲，现在照着抄就好；i++是i = i + 1的简写，第7章讲运算符时也会再见面。
二、顺序结构：从上到下，一行一行
顺序结构是最简单、也是程序默认的执行方式：计算机会从第一行开始，老老实实地一行一行往下执行，就像早上起床→穿衣→洗漱，顺序不能乱。
cpp
#include <iostream>
using namespace std;
int main() {
int pricePen = 2; // 第1行：铅笔每支2元
int numPen = 3; // 第2行：买3支
int priceBook = 5; // 第3行：笔记本每本5元
int numBook = 2; // 第4行：买2本
int total = pricePen * numPen + priceBook * numBook; // 第5行：算总价
cout << "一共要花" << total << "元" << endl; // 第6行：输出结果
return 0;
}输出结果：
一共要花16元计算机就是按 ① → ② → ③ → ④ → ⑤ → ⑥ 的顺序执行的，不会跳行，也不会倒回去。
| 行号 | 做了什么 | 变量变化 |
|---|---|---|
| 1 | 记下铅笔单价 | pricePen = 2 |
| 2 | 记下铅笔数量 | numPen = 3 |
| 3 | 记下笔记本单价 | priceBook = 5 |
| 4 | 记下笔记本数量 | numBook = 2 |
| 5 | 计算总价 2×3+5×2 | total = 16 |
| 6 | 打印结果 | 屏幕显示：一共要花16元 |
高频考点 🔥：变量必须"先赋值，再使用"！ 想输出一个变量，就必须先给它赋值。如果写成
cout << total;却从来没给total赋过值，编译器会报错或输出一个奇怪的随机数，就像你还没做饭就喊"开饭啦"。
易错点 ⚠️：交换两个变量的值，要请第三个"空盒子"帮忙。 不能直接
a = b; b = a;（这样 a 原来的值就被覆盖弄丢了）：cppint a = 3, b = 5; int t = a; // ① 先把 a 的东西放进空盒子 t 存起来 a = b; // ② 把 b 的东西放进 a b = t; // ③ 把 t 里存的原来 a 的东西放进 b // 结果：a 变成 5，b 变成 3
三、分支结构：让程序学会"做选择"
顺序结构只会"一条道走到黑"。可生活中经常要看情况办事：下雨就带伞，考试及格就开心……这就需要分支结构（也叫选择结构）。
C++ 分支结构的两大"标点灵魂"请先记牢：
- 小括号
( )—— 条件写在小括号里，像在问一句话："这件事成立吗？" - 大括号
{ }—— 条件成立时要执行的语句，用大括号围起来，像一个"小团队"。
（每条语句末尾的分号 ; 也不能忘，它像一句话说完后的句号。）
3.1 if 单分支：条件成立才做
cpp
if (条件) {
条件成立时要做的事;
}cpp
// if 单分支示例：温度太高就提醒
int temp = 36;
if (temp >= 35) { // 如果温度达到 35 度
cout << "注意防暑" << endl; // 大括号里的话：条件成立才执行
}
cout << "正常出行" << endl; // 大括号外面：不管热不热都执行输出结果：
注意防暑
正常出行如果把 temp 改成 20，条件不成立，程序就只输出"正常出行"。
高频考点 🔥：大括号
{ }决定了"哪些代码属于 if"。 大括号里可以写多条语句，它们是一个整体；如果不写大括号，只有紧挨着的第一条语句属于 if，很容易出错。一级考试建议：哪怕只有一条语句，也乖乖写上大括号。
3.2 if...else：二选一
"如果……就……，否则就……"——两种情况选一个，用 if...else：
cpp
if (条件) {
条件成立做这件事;
} else {
条件不成立做那件事;
}例题1：判断奇偶数 ⭐⭐⭐⭐
题目： 输入一个整数 n，判断它是奇数还是偶数。
思路： 回忆第7章学的取余运算 %：一个数除以 2，余数是 0 就是偶数，余数是 1 就是奇数。
cpp
int n;
cin >> n;
if (n % 2 == 0) { // 除以2余数为0？
cout << "偶数" << endl;
} else { // 否则
cout << "奇数" << endl;
}| 输入 | 输出 |
|---|---|
7 | 奇数 |
8 | 偶数 |
例题2：成绩及格还是不及格 ⭐⭐⭐⭐
题目： 输入一个考试成绩，60 分及以上输出"及格"，否则输出"不及格"。
cpp
int score;
cin >> score;
if (score >= 60) {
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}| 输入 | 输出 |
|---|---|
80 | 及格 |
55 | 不及格 |
60 | 及格（60 分整也算及格，因为用的是 >=） |
易错点 ⚠️：判断相等用两个等号
==，不是一个等号=！
写法 含义 例子 =（一个等号）赋值：把右边的值放进左边的变量 age = 18;（把 18 放进 age）==（两个等号）判断相等：比较两边是否一样，结果是真/假 age == 18（age 等于 18 吗？）小口诀：一个等号是"放进去"，两个等号是"比一比"。把
if (x = 5)写进条件里是典型错误。
3.3 if...else if...else：多选一
情况超过两种怎么办？比如判断一个数是正数、负数还是零，或者成绩分优秀、良好、及格、不及格——用 if...else if...else 阶梯：
cpp
if (条件1) {
事情1;
} else if (条件2) { // "否则如果……"
事情2;
} else {
事情3; // 以上条件都不成立时的"兜底"
}例题3：正数、负数还是零 ⭐⭐⭐⭐⭐
cpp
int n;
cin >> n;
if (n > 0) { // 情况一：大于0
cout << "正数" << endl;
} else if (n < 0) { // 情况二：否则如果小于0
cout << "负数" << endl;
} else { // 兜底：既不大于0也不小于0，那就是0
cout << "零" << endl;
}| 输入 | 输出 |
|---|---|
3 | 正数 |
-2 | 负数 |
0 | 零 |
例题4：成绩分等级 ⭐⭐⭐⭐⭐
题目： 输入成绩（0～100），90 分及以上输出"优秀"，80～89 输出"良好"，60～79 输出"及格"，60 以下输出"不及格"。
cpp
int score;
cin >> score;
if (score >= 90) {
cout << "优秀" << endl;
} else if (score >= 80) { // 能走到这里说明 score < 90
cout << "良好" << endl;
} else if (score >= 60) { // 能走到这里说明 score < 80
cout << "及格" << endl;
} else {
cout << "不及格" << endl;
}高频考点 🔥：多分支阶梯"命中一个就收手"！ 程序从上到下依次判断条件，第一个成立的条件执行完后，整个分支立刻结束，后面的
else if、else再也不看。所以条件要按从严格到宽松的顺序写：如果先写score >= 60，那 95 分也会被拦下判成"及格"，就闹笑话了。
3.4 switch 语句：多路选择的"电梯按钮"
当要判断的是一个整数或字符变量等于哪个固定值时，除了一长串 else if，C++ 还提供了更整齐的 switch 语句，像电梯按钮：按到几楼就停几楼。
cpp
switch (整型或字符型表达式) {
case 常量1:
语句1;
break; // 干完活就"跳出电梯"
case 常量2:
语句2;
break;
default: // 所有 case 都没匹配上时的兜底
兜底语句;
}例题5：星期几的课程 ⭐⭐⭐⭐
cpp
int day;
cin >> day;
switch (day) {
case 1:
cout << "星期一：语文" << endl;
break;
case 2:
cout << "星期二：数学" << endl;
break;
case 3:
cout << "星期三：英语" << endl;
break;
default:
cout << "其他日子：休息或自行安排" << endl;
}输入 2，输出"星期二：数学"；输入 6，走 default 分支。
switch 也能判断字符（记得字符常量要加单引号）：
cpp
char grade;
cin >> grade;
switch (grade) {
case 'A':
cout << "优秀" << endl;
break;
case 'B':
cout << "良好" << endl;
break;
default:
cout << "继续加油" << endl;
}高频考点 🔥🔥：break 千万不能漏！漏了会"穿透"！
break的作用是"干完这个 case 就立刻跳出 switch"。如果漏写，程序不会停下，而是像下楼梯一样继续执行下面 case 的语句，这叫 case 穿透（fall-through）：cppint n = 1; switch (n) { case 1: cout << "一"; // 这里漏了 break！ case 2: cout << "二"; // 穿透下来，这行也会执行！ break; default: cout << "其他"; } // 输出：一二小口诀：case 是房间，break 是房门；不关门，就一路串门走到底！
易错点 ⚠️：case 后面只能跟整数或字符常量！
- ✅ 正确：
case 1:、case 'A':、case 0:- ❌ 错误：
case score >= 90:（不能写条件区间）、case x:（不能写变量）、case 1.5:（不能是小数）所以像"90 分以上优秀"这种范围判断，还得用
if...else if；switch 擅长的是"等于哪个固定值"。
🏆 考点深挖：case 穿透的妙用
前面说漏写 break 会导致穿透，这是 bug。但穿透有时候也能故意利用——当多个 case 要执行同一段代码时，就让它们"叠"在一起：
cpp
// 判断输入的月份有多少天（简化版，只考虑 28/30/31 天）
int month;
cin >> month;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
cout << "31天" << endl;
break;
case 4:
case 6:
case 9:
case 11:
cout << "30天" << endl;
break;
case 2:
cout << "28天（闰年29天）" << endl;
break;
default:
cout << "输入错误" << endl;
}1、3、5、7、8、10、12 月都是 31 天——让它们一个接一个地"穿透"下来，最后共用一段 cout << "31天" << endl; break;，代码就整齐多了。
💡 记忆窍门：多个 case 共用代码 = "叠罗汉"——上面的 case 没有 break，就一层层落到下面，直到遇到 break 才跳出。
🔍 深度辨析：什么时候用 switch，什么时候用 if-else？
| 场景 | 推荐用 | 原因 |
|---|---|---|
| 判断变量等于哪个固定值（整数/字符） | switch | 代码整齐、结构清晰 |
| 判断范围（大于、小于、区间） | if-else | switch 不能写范围条件 |
| 判断浮点型或字符串 | if-else | switch 不支持这些类型 |
| 分支数量少（2~3个） | if-else | 写起来更快 |
| 分支数量多（5个以上）且都是等值判断 | switch | 比一长串 else if 清爽 |
一级考试建议：编程题里两种都能用时，用你最熟的。选择题里常考"switch 能不能判断范围/小数/字符串"——记住：switch 只能判断整数和字符的等值。
3.5 三目运算符：迷你版 if-else（了解）
C++ 还有一个写在一行里的"迷你分支"——三目运算符 ?:：
cpp
条件 ? 值1 : 值2;意思是：条件成立，整个式子取"值1"；不成立，取"值2"。
cpp
int a = 3, b = 5;
int big = (a > b) ? a : b; // a>b 成立吗？成立取a，不成立取b → big = 5
cout << (n % 2 == 0 ? "偶数" : "奇数") << endl; // 一行搞定奇偶判断三目运算符本章先混个脸熟，第7章讲运算符时还会正式见面。
3.6 条件从哪来？比较与逻辑运算符
if 后面小括号里的"条件"，通常是一个比较表达式，结果只有两种：真（成立） 或 假（不成立）。
| 比较运算符 | 含义 | 例子 | 结果 |
|---|---|---|---|
== | 等于 | 3 == 3 | 真 |
!= | 不等于 | 3 != 5 | 真 |
> | 大于 | 10 > 8 | 真 |
< | 小于 | 10 < 8 | 假 |
>= | 大于或等于 | age >= 18 | 看 age 的值 |
<= | 小于或等于 | score <= 100 | 看 score 的值 |
想把两个条件组合起来，用 C++ 的三个逻辑运算符（注意：C++ 里 and/or/not 其实是合法的"替代关键字"，但等级考试和教材统一要求用符号 &&/||/!）：
| 逻辑运算符 | 含义 | 例子 | 什么时候成立 |
|---|---|---|---|
&& | 与（并且） | score >= 60 && score < 80 | 两边都成立 |
|| | 或（或者） | day == 6 || day == 7 | 两边有一个成立 |
! | 非（取反） | !(x > 0) | 原条件不成立时 |
cpp
// 判断闰年里常见的写法：能被4整除 并且 不能被100整除（一级先读一读、混个眼熟）
int year;
cin >> year;
if (year % 4 == 0 && year % 100 != 0) {
cout << "闰年" << endl;
}四、循环结构：让程序学会"重复劳动"
如果想在屏幕上打印 100 遍"你好"，难道要写 100 行 cout 吗？当然不用！循环结构就是让一段代码反复执行的法宝。C++ 有三种循环：知道重复几次用 for，看条件决定要不要继续用 while，想"先做一次再说"用 do...while。
4.1 for 循环：知道重复几次时用它
cpp
for (初始化; 条件; 更新) {
循环体（重复做的事）;
}小括号里有三个部分，用两个分号隔开：
| 位置 | 写什么 | 例子 | 作用 |
|---|---|---|---|
| 初始化 | 计数器从几开始 | int i = 1 | 喊"预备——起"，只执行 1 次 |
| 条件 | 什么时候继续转 | i <= 10 | 每圈开始前检查，成立才转 |
| 更新 | 每圈结束后怎么变 | i++ | i 每次加 1，朝终点靠近 |
例题6：打印 1 到 10 ⭐⭐⭐⭐⭐
cpp
for (int i = 1; i <= 10; i++) {
cout << i << " ";
}
// 输出：1 2 3 4 5 6 7 8 9 10执行节奏：i = 1（起点）→ 检查 1 <= 10 成立 → 打印 → i++ 变 2 → 检查 2 <= 10……直到 i 变成 11，11 <= 10 不成立，循环结束。
例题7：1 加到 100 求和 ⭐⭐⭐⭐⭐
思路： 准备一个累加器 total，从 0 开始"攒钱"；计数器 i 从 1 数到 100，每圈把 i 攒进 total。
cpp
int total = 0; // 累加器：一开始什么都没攒，是0
for (int i = 1; i <= 100; i++) {
total = total + i; // 把当前的 i 攒进 total
}
cout << "1到100的和是" << total << endl;
// 输出：1到100的和是5050| 圈数 | i 的值 | total 累加后 |
|---|---|---|
| 第1圈 | 1 | 0+1 = 1 |
| 第2圈 | 2 | 1+2 = 3 |
| 第3圈 | 3 | 3+3 = 6 |
| … | … | … |
| 第100圈 | 100 | 4950+100 = 5050 |
| 结束 | i 变成 101，条件不成立 | 答案 5050 ✅ |
高频考点 🔥🔥：
i <= 10还是i < 10？差一个等号就差一圈！
for (int i = 1; i <= 10; i++)→ i 取 1～10，转 10 圈；for (int i = 1; i < 10; i++)→ i 取 1～9，转 9 圈。想数到几，条件里就让那个数"还能进得来"。这是一级选择题最爱挖的"差一"坑！
4.2 while 循环：次数不确定时用它
while 的意思是"当……的时候"：只要条件成立，就一遍一遍反复执行，直到条件不成立才停下。它特别适合事先不知道要重复几次的情况。
cpp
while (条件) {
反复做的事;
}例题8：不断输入数字求和，输入 -1 结束 ⭐⭐⭐⭐
题目： 输入若干个整数，以 -1 表示结束，求前面所有数的和。
cpp
int x, total = 0;
cin >> x; // 先读第一个数
while (x != -1) { // 只要不是结束标志-1，就继续
total = total + x;
cin >> x; // 再读下一个数，朝结束靠近！
}
cout << "和是" << total << endl;输入 3 5 2 -1，输出"和是10"。要输入几个数？事先不知道——这正是 while 的用武之地。
用 while 数数，三步套路缺一不可：
| 步骤 | 做什么 | 例子 | 忘了会怎样 |
|---|---|---|---|
| ① 定起点 | 循环开始前给计数器赋初值 | int i = 1; | 变量不存在，编译报错 |
| ② 写条件 | 决定什么时候继续转 | while (i <= 10) | 条件写错 → 多转或少转 |
| ③ 有变化 | 每转一圈让计数器变一变 | i++; | i 永远不变 → 死循环 ❌ |
cpp
int i = 1, total = 0;
while (i <= 100) {
total = total + i;
i++; // ③ 变化：千万别漏！
}
cout << total; // 5050易错点 ⚠️⚠️：while 最容易犯的错——忘记"变化"，程序死循环！ 如果循环体里漏了
i++;，i 永远是 1，1 <= 100永远成立，程序就会没完没了地转下去，像跑轮里的仓鼠停不下来，这叫死循环。上机考试时程序"卡住不动、刷屏不停"，先检查是不是忘记更新循环变量了！口诀：while 循环三件事，起点、条件、别忘变！
4.3 do...while 循环：先做一次，再问行不行
do...while 是 while 的"急性子兄弟"：它先把循环体执行一次，再判断条件，条件成立就接着转。
cpp
do {
循环体;
} while (条件); // ⚠️ 注意：结尾有一个分号！cpp
int i = 1;
do {
cout << i << " ";
i++;
} while (i <= 5);
// 输出：1 2 3 4 5高频考点 🔥：do...while 与 while 的区别——"先判断"还是"先执行"！
对比 while do...while 判断时机 先判断条件，成立才执行 先执行一次，再判断条件 最少执行 条件一开始就不成立 → 0 次 无论如何至少执行 1 次 结尾分号 没有 while (条件);分号不能漏生活比喻：while 像"先看票再进场"；do...while 像"先尝后买"——至少尝一口。
💡 do-while 典型应用场景
do-while 的特点是"至少执行一次"，特别适合这些场景：
| 场景 | 为什么用 do-while |
|---|---|
| 菜单程序 | 至少要显示一次菜单让用户选 |
| 猜数字游戏 | 至少要猜一次才知道对不对 |
| 密码验证 | 至少输入一次密码才知道对不对 |
| 循环输入直到正确 | 至少输入一次才判断合不合法 |
🎮 编程示例：猜数字游戏（do-while 经典应用）
程序先设定一个答案（比如 42），然后让用户反复猜，直到猜对为止。因为至少要猜一次，所以用 do-while 最合适：
cpp
#include <iostream>
using namespace std;
int main()
{
int answer = 42; // 设定答案
int guess; // 存用户猜的数
cout << "猜数字游戏！猜一个 1~100 之间的数" << endl;
do {
cout << "请输入你猜的数：";
cin >> guess;
if (guess > answer) {
cout << "太大了！" << endl;
} else if (guess < answer) {
cout << "太小了！" << endl;
} else {
cout << "恭喜你，猜对了！" << endl;
}
} while (guess != answer); // 没猜对就继续循环
return 0;
}运行示例：
猜数字游戏！猜一个 1~100 之间的数
请输入你猜的数：50
太大了！
请输入你猜的数：25
太小了！
请输入你猜的数：42
恭喜你，猜对了！🔥 为什么用 do-while 而不是 while？ 因为"请你猜一个数"这件事至少要发生一次——用户不可能一次都不猜就结束游戏。如果换成 while，就得在循环前先让用户猜一次，代码会重复。do-while 让"至少做一次"的逻辑表达得更自然。
⚠️ do-while 三大易错点
| 易错点 | 错误写法 | 正确写法 | 说明 |
|---|---|---|---|
| 结尾漏分号 | } while (条件) | } while (条件); | do-while 结尾必须有分号，while 循环没有。这是最高频考点！ |
| 条件写反了 | 想"猜对就退出"却写成 while (guess == answer) | while (guess != answer) | 条件是"继续循环的条件"，不是"退出的条件" |
| 以为和 while 完全一样 | 条件一开始就假也执行 0 次 | 至少执行 1 次 | 这是 do-while 和 while 最本质的区别 |
💡 一句话记住 do-while：先做后判，至少一次，结尾别忘分号！
4.4 break 急刹车 与 continue 跳过这一圈
循环里还有两个"交通指挥"关键字：
break：立刻跳出整个循环 🔴
程序一执行到 break，整个循环立刻结束，像跑步时遇到红灯直接停赛，剩下的圈数不跑了。
cpp
for (int i = 1; i <= 10; i++) {
if (i == 5) {
break; // 数到5，立刻"刹车"，整个循环结束
}
cout << i << " ";
}
// 输出：1 2 3 4continue：跳过本次剩余，直接进入下一圈 🟡
continue 不结束整个循环，只是这一圈剩下的话不做了，直接去更新计数器、进入下一圈，像跑步时绕过一个小水坑继续跑。
cpp
for (int i = 1; i <= 10; i++) {
if (i % 2 == 1) {
continue; // 是奇数？这圈跳过，后面的打印不执行
}
cout << i << " ";
}
// 输出：2 4 6 8 10高频考点 🔥：break 和 continue 别搞混！
关键字 动作 比喻 break立刻跳出整个循环（或 switch） 比赛退赛，直接回家 continue跳过本次剩余语句，进入下一次循环 这圈绕开水坑，继续跑下一圈 小提醒：
break在 switch 和循环里都能用；continue只能用在循环里。
五、三大结构综合小题
三大结构经常"手拉手"出现：循环负责重复，分支负责挑选，顺序负责一行行办事。
综合题：数数 1～20 中，既是偶数又能被 3 整除的数 ⭐⭐⭐⭐⭐
cpp
for (int i = 1; i <= 20; i++) { // 循环：一个一个数
if (i % 2 == 0 && i % 3 == 0) { // 分支：挑偶数且能被3整除
cout << i << " "; // 顺序：挑中了就打印
}
}
// 输出：6 12 18看，一个小小的程序里，三大结构全齐了：for 管重复，if 管选择，cout 管按顺序输出。一级编程题的骨架基本就是这个样子！
六、本章易错点大集合 ⚠️
| 易错点 | 错误写法 | 正确写法 / 说明 |
|---|---|---|
| 条件漏小括号 | if x > 0 {} | if (x > 0) {} —— 条件必须装在 ( ) 里 |
| 语句块漏大括号 | if 后多条语句不围 { } | 用 { } 围成整体，一条语句也建议写 |
| 语句漏分号 | cout << x | 每条语句末尾要有 ; |
| 等号用错 | if (x = 5) | 判断相等用 ==：if (x == 5) |
| for 少分号 | for (int i=1, i<=10, i++) | 三部分用两个分号隔开 |
| 循环差一圈 | 想数 1～10 写成 i < 10 | 应写 i <= 10，只转 9 圈就亏了 |
| while 死循环 | 漏写 i++; | 每圈必须让循环变量朝结束方向变化 |
| do...while 漏分号 | } while (i <= 5) | 结尾必须有分号：} while (i <= 5); |
| switch 漏 break | case 后不写 break; | 会穿透到下一个 case 继续执行 |
| case 后写条件 | case score >= 90: | case 后只能是整数/字符常量，范围判断用 if |
| 逻辑运算符写错 | a and b、not x | C++ 用 &&、||、! |
| break/continue 混 | 想跳过本次却用了 break | break 跳出整个循环，continue 只跳本次 |
一句话记忆： 条件装进小括号，干活围上大括号；判断相等两个杠（
==），for 里两个分号；while 别忘加一步，do-while 尾部分号留；switch 的 break 不能漏，漏了穿透一路走！
🧩 考点深挖：累加器与计数器的通用套路
编程题中，有两种"万能套路"出现频率极高，几乎每次考试都会遇到：
套路 1：累加器（求和）
cpp
int sum = 0; // ① 准备"空篮子"，一开始什么都没有
for (int i = 1; i <= n; i++) {
sum = sum + i; // ② 每圈把 i 放进篮子
}
// ③ 循环结束后，sum 里就是总和套路 2：计数器（数个数）
cpp
int count = 0; // ① 计数器清零
for (int i = 1; i <= n; i++) {
if (条件) { // ② 满足条件才算一个
count++;
}
}
// ③ 循环结束后，count 就是符合条件的个数| 对比项 | 累加器 sum | 计数器 count |
|---|---|---|
| 初始值 | 0 | 0 |
| 每次做什么 | 加上一个数（sum += i） | 满足条件就加 1（count++） |
| 最后得到 | 所有数的总和 | 符合条件的数量 |
| 例子 | 1~100 的和 | 1~100 中偶数的个数 |
💡 心法口诀：求和用累加器，计数用计数器。初始值都是 0，循环里各干各的活。
🔍 深度辨析：什么时候用 for，什么时候用 while？
很多同学纠结："这道题到底用 for 还是 while？"
其实两者可以互相替代，但各有擅长的场景：
| 场景 | 推荐用 | 原因 |
|---|---|---|
| 明确知道重复几次（如"循环10次"、"1到100"） | for | 三部分写在一起，结构清晰 |
| 不知道要重复几次（如"输入-1结束"） | while | 只管条件，不管次数 |
| 需要计数器变量参与计算 | for | 计数器 i 就在 for 头部，一目了然 |
💡 保命技巧：如果你实在拿不定主意，就用 for——大部分一级编程题都能用 for 解决。while 更适合"读入数据直到某个标志结束"的题目。
💡 拓展 · 超纲：嵌套循环入门
📚 拓展 · 超纲：多层分支 / 循环结构属于二级考纲，一级只要求单层循环。本节仅帮助你看懂简单代码，不作为一级考点。
一级阶段我们主要学"单层循环"，但你可能已经在想：如果我想打印一个 5 行 5 列的星号方阵，怎么办？
答案是——循环里面再套循环，这叫嵌套循环：
cpp
for (int i = 1; i <= 5; i++) { // 外层：控制行数
for (int j = 1; j <= 5; j++) { // 内层：控制每行打几个星
cout << "* ";
}
cout << endl; // 一行打完，换行
}输出：
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *嵌套循环的口诀：外层走一步，内层走一圈。就像时钟——分针（外层）走一格，秒针（内层）转一整圈。
📌 嵌套循环是 GESP 二级的重点内容，一级先了解概念、看懂简单代码即可。第9章编程题实战中我们还会再见面。
七、📝 实战练习
练习题 1（单选题）
题目： 语句 for (int i = 1; i <= 8; i++) 控制的循环体一共执行多少次？（ ）
A. 7 次 B. 8 次 C. 9 次 D. 不确定
🔑 点击查看答案与解析
答案： B
解析： i 依次取 1、2、…、8，共 8 个值，每取一个值循环体执行一次；i 变成 9 时 9 <= 8 不成立，循环结束。所以是 8 次。
练习题 2（程序阅读题）
题目： 以下程序段的输出是（ ）
cpp
int x = 2;
switch (x) {
case 1: cout << "A";
case 2: cout << "B";
case 3: cout << "C"; break;
default: cout << "D";
}A. B B. BC C. BCD D. ABC
🔑 点击查看答案与解析
答案： B
解析： x = 2 命中 case 2，输出 B；该 case 没有 break，穿透到 case 3 继续输出 C；遇到 break 跳出。所以输出"BC"。这就是漏写 break 的后果！
练习题 3（判断题）
题目： 1. C++ 中 if 的条件必须写在小括号 ( ) 里。（ ） 2. if (x = 3) 是判断 x 是否等于 3 的正确写法。（ ） 3. do...while 循环的循环体至少会执行一次。（ ） 4. switch 语句中，每个 case 后面的 break 都可以省略，不影响运行结果。（ ） 5. continue 的作用是立刻结束整个循环。（ ）
🔑 点击查看答案与解析
答案：
- ✅ 对。条件装在小括号里，语句块用大括号围起来。
- ❌ 错。
=是赋值，判断相等要用==：if (x == 3)。 - ✅ 对。do...while 先执行一次再判断条件，所以至少执行 1 次。
- ❌ 错。漏了 break 会发生穿透，继续执行后面 case 的语句。
- ❌ 错。立刻结束整个循环的是 break；continue 只跳过本次剩余语句。
练习题 4（编程题）
题目： 用 for 循环输出 1～10 之间的所有奇数，数字之间用空格隔开。
🔑 点击查看答案与解析
思路： 让 i 从 1 数到 10，用 if 挑出"除以 2 余数为 1"的数；也可以用 continue 跳过偶数。
参考答案（C++11）：
cpp
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 10; i++) {
if (i % 2 == 1) {
cout << i << " ";
}
}
return 0;
}输出结果：
1 3 5 7 9练习题 5（编程题）
题目： 输入一个 0～100 的成绩，90 及以上输出 A，80～89 输出 B，60～79 输出 C，60 以下输出 D。
🔑 点击查看答案与解析
参考答案（C++11）：
cpp
#include <iostream>
using namespace std;
int main() {
int score;
cin >> score;
if (score >= 90) {
cout << "A" << endl;
} else if (score >= 80) {
cout << "B" << endl;
} else if (score >= 60) {
cout << "C" << endl;
} else {
cout << "D" << endl;
}
return 0;
}练习题 6（单选题）
题目： 关于 while 和 do...while 的区别，下列说法正确的是（ ）
A. while 先执行后判断，do...while 先判断后执行 B. while 至少执行 1 次，do...while 可能执行 0 次 C. while 先判断后执行，do...while 先执行后判断 D. while 和 do...while 完全一样，没有区别
🔑 点击查看答案与解析
答案： C
解析： while 是"先看票再进场"——先判断条件，成立才执行；do...while 是"先尝后买"——先执行一次再判断，所以至少执行 1 次。A、B 说反了，D 明显不对。选 C。
练习题 7（程序阅读题）
题目： 下面程序的输出结果是（ ）
cpp
for (int i = 1; i <= 5; i++) {
if (i == 3) {
continue;
}
cout << i << " ";
}A. 1 2 3 4 5 B. 1 2 C. 1 2 4 5 D. 3 4 5
🔑 点击查看答案与解析
答案： C
解析： continue 的作用是跳过本次循环的剩余语句，进入下一次循环。当 i=3 时，continue 跳过了 cout，所以 3 没有被输出。i=1、2、4、5 都正常输出。结果是 1 2 4 5。
如果把 continue 换成 break，答案就是 B（只输出 1 2，到 3 就跳出整个循环了）。
选 C。
练习题 8（判断题）
题目： 1. for 循环的小括号里有三个部分，用两个逗号隔开。（ ） 2. while 循环体中如果没有让循环变量变化的语句，可能会死循环。（ ） 3. switch 语句中 default 分支是必须写的，不能省略。（ ） 4. 三目运算符 ?: 可以用来替代简单的 if...else 语句。（ ） 5. 逻辑运算符 && 表示"或者"，只要有一个条件成立结果就为真。（ ）
🔑 点击查看答案与解析
答案：
- ❌ 错。用两个分号隔开，不是逗号。
- ✅ 对。忘记更新循环变量，条件永远成立，就是死循环。
- ❌ 错。default 是可选的，可以省略，省略后如果所有 case 都不匹配，就什么都不做。
- ✅ 对。简单的二选一赋值可以用三目运算符写得更简洁。
- ❌ 错。
&&是"与（并且）"，两边都成立才为真；||才是"或（或者）"。
练习题 9（程序阅读题）
题目： 下面程序运行后，sum 的值是多少？（ ）
cpp
int sum = 0;
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) {
sum = sum + i;
}
}A. 10 B. 25 C. 30 D. 55
🔑 点击查看答案与解析
答案： C
解析： 程序在计算 1 到 10 中所有偶数的和：2 + 4 + 6 + 8 + 10 = 30。
一步步验证：
- i=1（奇数，跳过）
- i=2（偶数，sum=2）
- i=3（奇数，跳过）
- i=4（偶数，sum=6）
- i=5（奇数，跳过）
- i=6（偶数，sum=12）
- i=7（奇数，跳过）
- i=8（偶数，sum=20）
- i=9（奇数，跳过）
- i=10（偶数，sum=30）
选 C。
八、📊 考点总结表
| 考点 | 重要程度 | 出题形式 |
|---|---|---|
| 顺序结构（从上到下依次执行） | ⭐⭐⭐ | 判断/读程序 |
| 变量先赋值再使用、交换变量借第三个盒子 | ⭐⭐⭐ | 判断/改错 |
| if 语法：小括号装条件、大括号围语句 | ⭐⭐⭐⭐⭐ | 选择/编程 |
| if...else 二选一（奇偶、及格） | ⭐⭐⭐⭐⭐ | 编程大题 |
| if...else if...else 多选一（命中即停） | ⭐⭐⭐⭐ | 选择/编程 |
= 赋值与 == 判断相等的区别 | ⭐⭐⭐⭐⭐ | 判断/选择 |
| switch 语法与 case 常量要求 | ⭐⭐⭐⭐ | 选择/读程序 |
| switch 漏 break 的穿透现象 | ⭐⭐⭐⭐⭐ | 选择/判断 |
三目运算符 ?:（了解） | ⭐⭐ | 选择 |
比较运算符与逻辑运算符 && || ! | ⭐⭐⭐⭐ | 选择/编程 |
| for 循环三件套与循环次数（差一坑） | ⭐⭐⭐⭐⭐ | 选择/判断/编程 |
| while 条件循环与计数三步套路 | ⭐⭐⭐⭐⭐ | 编程大题 |
| do...while 先执行后判断、结尾分号 | ⭐⭐⭐⭐ | 选择/判断 |
| 死循环成因（忘记更新循环变量） | ⭐⭐⭐⭐ | 判断/选择 |
| break 跳出整个循环 / continue 跳过本次 | ⭐⭐⭐⭐ | 选择/读程序 |
| 求和累加器、奇偶判断、计数等综合套路 | ⭐⭐⭐⭐⭐ | 编程大题 |
┌──────────────────────────────────────────────────────────────┐
│ ⭐ 第6章必背速记卡（三大基本结构） │
├──────────────────────────────────────────────────────────────┤
│ 1. 三大结构：顺序（从上到下）、分支（if/switch）、循环 │
│ （for/while/do-while） │
│ 2. if条件装小括号，语句围大括号；=赋值，==判断相等 │
│ 3. if...else if...else：从上往下判断，命中一个就收手 │
│ 4. switch判断等于哪个固定值；case后是常量，不能写范围 │
│ 5. switch漏break会穿透；case是房间，break是房门 │
│ 6. for循环三部分：初始化;条件;更新（两个分号隔开） │
│ 7. for循环差一坑：i<=10转10次，i<10转9次 │
│ 8. while三件套：起点、条件、别忘变（忘了变=死循环） │
│ 9. do...while先执行后判断，至少执行1次，结尾有分号 │
│ 10. break跳出整个循环/switch；continue跳过本次进入下一次 │
│ 11. 比较运算符：== != > < >= <= │
│ 12. 逻辑运算符：&&与（都成立）、||或（一个成立）、!非（取反） │
│ 13. 累加器：sum初始为0，每圈加一个数 │
│ 14. 计数器：count初始为0，满足条件就加1 │
│ 15. 交换变量要借第三个空盒子做中转 │
│ 16. 综合套路：循环管重复，分支管挑选，顺序管一行行办事 │
└──────────────────────────────────────────────────────────────┘📖 下章预告：第7章我们将系统学习 C++ 的运算符——算术运算符、赋值运算符、比较运算符、逻辑运算符、自增自减、三目运算符……以及它们的优先级和结合性。运算符就是编程的"四则运算规则"，掌握了它们，你就能写出更复杂、更灵活的表达式了！