Appearance
第8章 多层循环语句
🎯 本章学习目标
学完本章，你将能够：
- ✅ 掌握 while、do-while、for 三种循环的语法
- ✅ 理解循环三要素（初始化、条件、更新）
- ✅ 区分 while 与 do-while 的执行时机差异
- ✅ 掌握双重循环的执行规则（外层走一步，内层走一圈）
- ✅ 学会计算嵌套循环的执行次数
- ✅ 能用嵌套循环打印矩形、三角形、九九乘法表
- ✅ 掌握 break 和 continue 的区别与使用
- ✅ 理解 break 只跳出本层循环的特性
- ✅ 学会用枚举思想解决简单问题
- ✅ 掌握求和、计数、求最值三大循环套路
- ✅ 理解死循环成因和 off-by-one 边界错误
🗺️ 本章知识图谱
多层循环语句
├── 三种循环基础
│ ├── while：先判断后执行，最少0次
│ ├── do-while：先执行后判断，最少1次
│ ├── for：计数循环首选（初始化;条件;更新）
│ └── 循环三要素：初始化、条件、更新
├── 循环嵌套 ⭐⭐⭐⭐⭐
│ ├── 执行规则：外层走一步，内层走一圈
│ ├── 执行次数：外层×内层（内层随外层变化则逐圈累加）
│ ├── 外层控制"行"，内层控制"列"
│ └── 循环变量跟踪表
├── 图形打印经典题型
│ ├── 矩形：外层固定行，内层固定列
│ ├── 直角三角形：内层j从1到i
│ ├── 倒三角形：外层倒着数
│ └── 九九乘法表：式子j*i=积
├── break 与 continue
│ ├── break：跳出本层循环（急刹车）
│ ├── continue：跳过本次循环（跨水坑）
│ └── break只跳一层，想跳多层需用标志变量
├── 枚举思想雏形
│ ├── 两数之和：双重循环枚举
│ ├── 凑硬币：两重循环+第三量计算
│ └── 鸡兔同笼：一重循环+第二量计算
├── 三大基础套路
│ ├── 求和：累加器 sum=0，sum+=x
│ ├── 计数：计数器 cnt=0，满足条件cnt++
│ └── 求最值：打擂法 max=首值，更大就替换
└── 常见错误
├── 死循环：忘记更新、更新方向反了
├── off-by-one：< 和 <= 混淆
└── 内层循环变量忘记重置一、三种循环语句回顾
循环就是让计算机重复执行一段代码。二级考纲要求掌握三种循环：while、do...while、for。
1.1 while 循环：先判断，后执行 ⭐⭐⭐⭐
cpp
while (条件) {
循环体;
}执行流程：先判断条件 → 条件为真才执行循环体 → 回来再判断。如果一开始条件就为假，循环体一次都不执行。
循环三要素（写循环缺一不可，忘记"更新"就会死循环🔥）：
| 要素 | 作用 | 示例（求 1+2+…+100） | 忘记的后果 |
|---|---|---|---|
| ① 初始化 | 循环开始前给变量赋初值 | int i = 1, sum = 0; | 变量是垃圾值，结果全错 |
| ② 循环条件 | 决定什么时候继续/停止 | while (i <= 100) | 条件写错 → 少算或多算 |
| ③ 循环更新 | 每次循环改变变量，推动走向结束 | i++; | 永远满足条件 → 死循环 ❌ |
cpp
#include <iostream>
using namespace std;
int main() {
int i = 1, sum = 0; // ① 初始化
while (i <= 100) { // ② 循环条件
sum = sum + i;
i++; // ③ 循环更新（千万不能忘！）
}
cout << sum << endl; // 输出：5050
return 0;
}易错点 ⚠️：
while (i <= 100)条件为假时循环体一次都不执行。例如int i = 5; while (i > 10) ...，循环体直接跳过——这是和 do-while 最大的区别，判断题高频出现。
1.2 do...while 循环：先执行，后判断 ⭐⭐⭐
cpp
do {
循环体;
} while (条件); // 注意末尾有分号！执行流程：先执行一次循环体 → 再判断条件 → 为真就继续。无论条件真假，循环体至少执行一次。
典型场景：菜单选择、密码重试——至少要让用户输入一次，输错了再重来。
cpp
#include <iostream>
using namespace std;
int main() {
int pwd;
do {
cin >> pwd; // 先执行：至少输入一次
if (pwd != 888)
cout << "密码错误，重试" << endl;
} while (pwd != 888); // 后判断：不对就继续
cout << "登录成功！" << endl;
return 0;
}
// 输入：
// 123
// 456
// 888
// 输出：
// 密码错误，重试
// 密码错误，重试
// 登录成功！高频考点 🔥：
- while：先判断后执行，条件为假时0 次；
- do-while：先执行后判断，至少 1 次；
- C++ 的 do-while 末尾必须有分号
while(条件);，漏写编译报错；
1.3 for 循环：计数循环的首选 ⭐⭐⭐⭐⭐
当循环次数已知时（比如"打印 5 行""枚举 1~100"），for 最简洁。
C++ 写法： for (初始化; 条件; 更新) { 循环体; }
cpp
for (int i = 1; i <= 100; i++) { // 初始化; 条件; 更新 三部分写在一行
sum += i;
}1.4 三种循环对比总表
| 对比项 | while | do-while | for |
|---|---|---|---|
| 判断时机 | 先判断后执行 | 先执行后判断 | 先判断后执行 |
| 最少执行次数 | 0 次 | 1 次 | 0 次 |
| 适用场景 | 次数不定，靠条件结束（如读到特定值） | 至少执行一次（菜单、重试） | 次数已知的计数循环 |
| C++ 语法 | while(c){...} | do{...}while(c); | for(init;c;upd){...} |
三种循环本质上可以互相改写，考试中计数优先 for、条件不定用 while、至少一次用 do-while。
二、循环嵌套（本章核心 🔥🔥🔥）
2.1 什么是循环嵌套
循环里面再写循环，就是循环嵌套。最常见的是双重循环（两层），二级考试以双重为主。
执行规则一句话记住：
外层循环走一步，内层循环走一整圈。
cpp
for (int i = 1; i <= 3; i++) { // 外层：控制"行"
for (int j = 1; j <= 4; j++) { // 内层：控制"列"
cout << i << "," << j << " ";
}
cout << endl; // 内层走完一圈，外层换一行
}输出（实际运行核对 ✅）：
1,1 1,2 1,3 1,4
2,1 2,2 2,3 2,4
3,1 3,2 3,3 3,42.2 双重循环执行次数：外 × 内 ⭐⭐⭐⭐⭐
内层循环体总执行次数 = 外层次数 × 内层次数。
- 外层循环 m 次，每次内层都完整执行 n 次 → 内层循环体一共执行 m × n 次。
- 上例：外层 3 次 × 内层 4 次 = 12 次。
| 外层 i | 内层 j 取值 | 内层执行次数 |
|---|---|---|
| i=1 | 1,2,3,4 | 4 次 |
| i=2 | 1,2,3,4 | 4 次 |
| i=3 | 1,2,3,4 | 4 次 |
| 合计 | — | 3×4 = 12 次 |
高频考点 🔥： 选择题常给一段双重循环问"循环体执行多少次"或"输出几个数"。算法：先数外层转几圈，再数每圈内层转几圈，相乘。注意内层范围若与外层变量有关（如
j从 1 到i），就要逐圈累加（见乘法表分析）。
2.3 循环变量跟踪表：读懂嵌套循环的神器
遇到"阅读程序写输出"的题，不要用眼睛硬看，拿出草稿纸画跟踪表，把每一圈的变量值填进去。例如：
cpp
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= i; j++) { // 注意：内层上界是 i！
cout << "*";
}
cout << endl;
}| 外层 i | 内层 j 取值 | 内层次数 | 本行输出 |
|---|---|---|---|
| 1 | 1 | 1 | * |
| 2 | 1, 2 | 2 | ** |
| 3 | 1, 2, 3 | 3 | *** |
总执行次数 = 1+2+3 = 6 次（不是 3×3！因为内层上界随 i 变化）。
易错点 ⚠️： 内层循环的范围依赖外层变量时（
j<=i、j<i等），每一圈内层次数都不同，必须列表逐圈算，切忌直接 m×n。
三、经典图形打印 ⭐⭐⭐⭐⭐
图形打印是二级编程题超高频题型。万能思路：外层循环控制行数，内层循环控制每行的符号个数，每行打完换行。
3.1 例题1：打印矩形
题目： 打印 4 行、每行 5 个 * 的矩形。
思路： 行数固定 4 → 外层 i 循环 4 次；每行 5 个星 → 内层 j 循环 5 次打印 *（不换行）；内层结束后 cout << endl; 换行。
cpp
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 4; i++) { // 外层：4行
for (int j = 1; j <= 5; j++) { // 内层：每行5个*
cout << "*";
}
cout << endl; // 一行打完，换行
}
return 0;
}输出（实际运行核对 ✅）：
*****
*****
*****
*****3.2 例题2：打印直角三角形
题目： 打印 n=5 行的直角三角形，第 i 行有 i 个 *。
思路： 关键规律——第 i 行打印 i 个星，所以内层循环次数 = 外层变量 i。
cpp
#include <iostream>
using namespace std;
int main() {
int n = 5;
for (int i = 1; i <= n; i++) { // 第 i 行
for (int j = 1; j <= i; j++) { // 本行打印 i 个*（次数随 i 增长！）
cout << "*";
}
cout << endl;
}
return 0;
}输出（实际运行核对 ✅）：
*
**
***
****
*****3.3 例题3：打印倒三角形
题目： 打印 n=5 行的倒三角，第 1 行 5 个星，逐行减少到 1 个。
思路： 外层倒着数：i 从 n 递减到 1，内层每行打印 i 个星。
cpp
#include <iostream>
using namespace std;
int main() {
int n = 5;
for (int i = n; i >= 1; i--) { // 外层倒着数：5,4,3,2,1
for (int j = 1; j <= i; j++) { // 第 i 行打印 i 个*
cout << "*";
}
cout << endl;
}
return 0;
}输出（实际运行核对 ✅）：
*****
****
***
**
*3.4 例题4：九九乘法表 🔥🔥🔥
题目： 打印九九乘法表，第 i 行输出 i 个式子 j*i=积（j 从 1 到 i）。
思路： 外层 i 控制"行"（第二个乘数，1~9），内层 j 控制"列"（第一个乘数，1~i）。第 i 行有 i 个式子，内层共执行 1+2+…+9 = 45 次。
cpp
#include <iostream>
#include <iomanip> // setw 所需头文件
using namespace std;
int main() {
for (int i = 1; i <= 9; i++) { // 外层：行，i 是第二个乘数
for (int j = 1; j <= i; j++) { // 内层：列，j 从1到i
cout << j << "*" << i << "="
<< left << setw(2) << i*j // 积占2位左对齐，排版整齐
<< " ";
}
cout << endl; // 每行结束换行
}
return 0;
}输出（实际运行核对 ✅）：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81图形题万能模板 🔥：
- 定行数：外层循环跑几行（正三角 i 从小到大，倒三角 i 从大到小）；
- 定每行符号数：内层循环跑几次——矩形是固定值，三角是
i或n-i+1；- 定换行：内层走完一圈，立刻换行；
- 打印符号用"不换行输出"（
cout<<"*"；）。把这个模板套到数字三角形、字母三角形上同样有效，比如把
*换成j就打印出1 / 12 / 123 / 1234。
四、break 与 continue：循环的"急刹车"和"跳过" ⭐⭐⭐⭐
| 关键字 | 作用 | 生活类比 | 范围 |
|---|---|---|---|
| break | 立刻跳出本层循环，循环提前结束 | 跑步遇到红灯，直接停赛 | 只跳一层 |
| continue | 跳过本次循环剩下的语句，直接进入下一次判断 | 跑步跨过一个水坑，继续跑 | 不结束循环 |
cpp
#include <iostream>
using namespace std;
int main() {
for (int i = 1; i <= 10; i++) {
if (i % 3 == 0) continue; // 3的倍数：跳过本次，不打印
if (i > 7) break; // 超过7：立刻结束整个循环
cout << i << " ";
}
cout << endl;
return 0;
}
// 输出：1 2 4 5 7执行过程跟踪：
| i | i%3==0？ | i>7？ | 动作 |
|---|---|---|---|
| 1 | 否 | 否 | 打印 1 |
| 2 | 否 | 否 | 打印 2 |
| 3 | 是 | — | continue，跳过 |
| 4 | 否 | 否 | 打印 4 |
| 5 | 否 | 否 | 打印 5 |
| 6 | 是 | — | continue，跳过 |
| 7 | 否 | 否 | 打印 7 |
| 8 | 否 | 是 | break，循环结束 |
高频考点 🔥：
- break 只跳出"本层"循环！双重循环中内层写 break，只结束内层，外层照常转。想一次跳出多层需要借助标志变量，或 C++ 的
goto（了解即可：goto 标号;可直接跳到指定位置，能跳出多层循环，但会破坏程序结构，考试只要求认识，不建议在编程题中使用）。- continue 是"这次算了，下次继续"，循环没有结束；break 是"整个循环到此为止"。
五、枚举思想雏形：用双重循环"穷举" ⭐⭐⭐⭐
三级会系统学习枚举法，二级阶段先建立雏形：把所有可能的情况一个个试过去，满足条件就记录。一个变量不确定用一层循环，两个变量都不确定就用双重循环。
5.1 例题1：穷举两数之和
题目： 在 1~8 中找出两个不同的数，使它们的和等于 9，输出所有数对。
思路： 两个数 a、b 都不确定 → 双重循环枚举。为避免重复（如 1+8 和 8+1 算同一组），让 b 从 a+1 开始枚举。
cpp
#include <iostream>
using namespace std;
int main() {
for (int a = 1; a <= 8; a++) {
for (int b = a + 1; b <= 8; b++) { // b 从 a+1 开始，避免重复数对
if (a + b == 9) {
cout << a << "+" << b << "=9" << endl;
}
}
}
return 0;
}输出（实际运行核对 ✅）：
1+8=9
2+7=9
3+6=9
4+5=95.2 例题2：百钱百鸡简化版（凑硬币）
题目： 用 1 分、2 分、5 分硬币凑出 1 角钱（10 分），每种硬币数量不限，共有多少种凑法？
思路： 枚举 5 分硬币 x 枚（0~2）、2 分硬币 y 枚（0~5），1 分硬币数量 z = 10 - 5x - 2y 直接算出，z ≥ 0 就是一种合法凑法。这正是"双重循环 + 第三量直接计算"的经典套路。
cpp
#include <iostream>
using namespace std;
int main() {
int cnt = 0;
for (int x = 0; x <= 2; x++) { // 5分硬币：最多2枚
for (int y = 0; y <= 5; y++) { // 2分硬币：最多5枚
int z = 10 - 5*x - 2*y; // 1分硬币数量直接算
if (z >= 0) { // 1分硬币数不能为负
cnt++;
}
}
}
cout << "共有 " << cnt << " 种凑法" << endl;
return 0;
}
// 输出：共有 10 种凑法枚举套路小结 🔥： 确定枚举范围 → 双重循环逐一代入 → if 检验条件 → 计数或输出。范围尽量收紧（5 分硬币最多 2 枚而不是 10 枚），能直接算出来的量就不要再开第三层循环。
六、典型编程题：求和/计数/求最值、因子与质数 ⭐⭐⭐⭐⭐
6.1 三大基础套路：求和、计数、求最值
循环题的半壁江山都是这三个套路，务必形成肌肉记忆：
| 套路 | 核心写法 | 初始化 | 循环内动作 |
|---|---|---|---|
| 求和 | 累加器 | sum = 0 | 满足条件 sum += x |
| 计数 | 计数器 | cnt = 0 | 满足条件 cnt++ / cnt += 1 |
| 求最值 | 打擂台 | max = 第一个数（或极小值） | if (x > max) max = x; |
例：输入 n 个整数，求和、计数（统计正数个数）、求最大值
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
int sum = 0, cnt = 0, mx = -1000000; // 求和、计数、最大值初始化
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x; // 求和：累加
if (x > 0) cnt++; // 计数：正数才+1
if (x > mx) mx = x; // 打擂台：更大就替换
}
cout << "和=" << sum << " 正数个数=" << cnt << " 最大值=" << mx << endl;
return 0;
}
// 输入：5 -3 8 2 -1 6
// 输出：和=12 正数个数=3 最大值=86.2 例题：找因子
题目： 输入正整数 n，输出它的所有因子（能整除 n 的正整数）。
思路： 枚举 i 从 1 到 n，若 n % i == 0（余数为 0），i 就是因子。
cpp
#include <iostream>
using namespace std;
int main() {
int n = 12;
for (int i = 1; i <= n; i++) {
if (n % i == 0) { // 余数为0 → i 能整除 n
cout << i << " ";
}
}
cout << endl;
return 0;
}
// 输出：1 2 3 4 6 126.3 例题：质数初步判断
题目： 输出 2~20 之间所有的质数。质数：大于 1，且只能被 1 和自身整除的数。
思路（二级基础版）： 对每个数 n，枚举除数 i 从 2 到 n-1，只要有一个能整除 n，就不是质数（用 break 提前结束）；全部都不能整除，才是质数。
cpp
#include <iostream>
using namespace std;
int main() {
for (int n = 2; n <= 20; n++) {
bool isPrime = true; // 先假设 n 是质数
for (int i = 2; i < n; i++) { // 枚举可能的因子
if (n % i == 0) {
isPrime = false; // 找到因子 → 不是质数
break; // 不用再试了，提前退出内层
}
}
if (isPrime) cout << n << " ";
}
cout << endl;
return 0;
}
// 输出：2 3 5 7 11 13 17 19高频考点 🔥： 质数判断的"假设-推翻"模式——先用布尔变量
isPrime = true假设是质数，内层循环一旦发现因子就置 false 并 break；循环结束后看标志位下结论。注意 1 不是质数，2 是最小的质数。
七、死循环与边界错误：循环题两大"坑" ⚠️
7.1 死循环：程序停不下来
| 死循环成因 | 错误示例 | 后果 |
|---|---|---|
| 忘记更新循环变量 | while(i<=10){ sum+=i; } 漏了 i++ | i 永远是初值，无限循环 |
| 更新方向写反 | for(int i=1;i<=10;i--) | i 越来越小，永不到 10 |
| 条件恒为真 | while(1) / while(true) 且没有 break | 无限循环（故意写时必须配 break） |
| break 永远执行不到 | 跳出条件写错 | 死循环 |
while(true)（也可写while(1)；）本身不是错——模拟 do-while、菜单程序都要用它，但内部必须有能到达的 break，否则就是死循环。
7.2 差一错误（off-by-one）：多一次还是少一次
| 需求 | 正确写法 | 常见错误 | 错误后果 |
|---|---|---|---|
| 循环 n 次 | i=1;i<=n | i=1;i<n | 少循环 1 次 |
| 数组/累加边界 | <= 与 < 分清 | 混用 | 首尾元素出错 |
避坑方法：循环变量跟踪表。 考试时在草稿纸上列出：循环开始前变量初值 → 每一圈条件判断结果 → 变量更新后的值 → 循环结束时变量是多少。手工走 2~3 圈 + 检查"最后一圈"，边界错误立刻现形。
易错点 ⚠️： 写完循环务必问自己三个问题：① 循环变量初始化了吗？② 条件在边界值（第一次、最后一次）时对吗？③ 每圈都在朝结束方向更新吗？三问能避开 90% 的循环错题。
八、📝 实战练习
练习题 1（单选题）
题目： 下面程序中，cout 输出语句共执行多少次？（ ）
cpp
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 4; j++)
cout << "*";A. 7 B. 12 C. 3 D. 4
🔑 点击查看答案与解析
答案： B
解析： 外层 3 圈（i=1,2,3），每圈内层完整执行 4 次（j=1,2,3,4），总次数 = 3 × 4 = 12 次，选 B。
练习题 2（编程题）
题目： 输入正整数 n（1≤n≤9），打印 n 行数字三角形：第 i 行依次输出 1 到 i。
样例输入： 4样例输出：
1
12
123
1234🔑 点击查看答案与解析
参考答案（C++11）：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) { // 外层：n行
for (int j = 1; j <= i; j++) { // 第i行打印 1~i
cout << j;
}
cout << endl;
}
return 0;
}练习题 3（编程题）
题目： 鸡兔同笼简化版：笼子里有鸡和兔共 20 只，脚共 56 只。请用枚举法编程求鸡和兔各多少只。
🔑 点击查看答案与解析
思路： 枚举鸡 x 只（0~20），兔 = 20 - x 只；检验脚数 2x + 4(20-x) 是否等于 56。
参考答案（C++11）：
cpp
#include <iostream>
using namespace std;
int main() {
for (int x = 0; x <= 20; x++) { // x：鸡的数量
int y = 20 - x; // 兔的数量
if (2*x + 4*y == 56) { // 脚共56只
cout << "鸡" << x << "只，兔" << y << "只" << endl;
}
}
return 0;
}
// 输出：鸡12只，兔8只练习题 4（程序阅读题）
题目： 阅读以下 C++ 程序，写出输出结果：
cpp
#include <iostream>
using namespace std;
int main() {
int sum = 0;
for (int i = 1; i <= 10; i++) {
if (i % 2 == 0) continue; // 偶数跳过
if (i > 7) break; // 大于7就结束
sum += i;
}
cout << sum << endl;
return 0;
}A. 25 B. 16 C. 36 D. 10
🔑 点击查看答案与解析
答案： B
解析： 逐圈跟踪：
| i | i%2==0? | i>7? | 动作 | sum |
|---|---|---|---|---|
| 1 | 否 | 否 | 累加 | sum=1 |
| 2 | 是 | — | continue，跳过 | sum=1 |
| 3 | 否 | 否 | 累加 | sum=4 |
| 4 | 是 | — | continue，跳过 | sum=4 |
| 5 | 否 | 否 | 累加 | sum=9 |
| 6 | 是 | — | continue，跳过 | sum=9 |
| 7 | 否 | 否 | 累加 | sum=16 |
| 8 | 否 | 是 | break，跳出循环 | sum=16 |
最终 sum = 1+3+5+7 = 16，选 B。
🔥 考点总结：continue 是"这次算了，下次继续"（不结束循环）；break 是"到此为止"（结束本层循环）。偶数被 continue 跳过了，i=8 时触发 break 提前退出。
练习题 5（单选题）
题目： 下列说法正确的是（ ）
① for(int i=0; i<5; i++) 循环体执行 5 次 ② do-while 循环的循环体至少执行一次 ③ while 循环的循环体至少执行一次 ④ 双重循环中，内层 break 可以跳出外层循环
A. ①② B. ②③ C. ①④ D. ②④
🔑 点击查看答案与解析
答案： A
解析：
- ① 正确 ✅：i 从 0 到 4，共 5 个值（0,1,2,3,4），循环体执行 5 次；
- ② 正确 ✅：do-while 先执行后判断，无论条件真假，循环体至少执行一次；
- ③ 错误 ❌：while 先判断后执行，条件一开始就为假时循环体一次都不执行（最少 0 次）；
- ④ 错误 ❌：break 只跳出当前所在那一层循环，内层 break 只能跳出内层，外层循环继续转。想一次跳出多层需要用标志变量或 goto。
选 A（①②）。
💡 记忆口诀：while 可能 0 次，do-while 至少 1 次，break 只跳一层。
练习题 6（程序阅读题）
题目： 阅读以下 C++ 程序，写出输出结果：
cpp
#include <iostream>
using namespace std;
int main() {
int cnt = 0;
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= i; j++) {
if (i + j > 4) cnt++;
}
}
cout << cnt << endl;
return 0;
}A. 4 B. 5 C. 6 D. 10
🔑 点击查看答案与解析
答案： C
解析： 逐圈跟踪内层循环中满足 i+j > 4 的次数：
| 外层 i | 内层 j 取值 | i+j > 4? | 计数+1 |
|---|---|---|---|
| i=1 | j=1 | 1+1=2 > 4？否 | 0 |
| i=2 | j=1 | 3 > 4？否 | 0 |
| j=2 | 4 > 4？否 | 0 | |
| i=3 | j=1 | 4 > 4？否 | 0 |
| j=2 | 5 > 4？是 | +1 | |
| j=3 | 6 > 4？是 | +1 | |
| i=4 | j=1 | 5 > 4？是 | +1 |
| j=2 | 6 > 4？是 | +1 | |
| j=3 | 7 > 4？是 | +1 | |
| j=4 | 8 > 4？是 | +1 |
合计：i=1 贡献 0 次，i=2 贡献 0 次，i=3 贡献 2 次，i=4 贡献 4 次，总计 = 0+0+2+4 = 6 次。
选 C。
🔥 解题技巧：内层循环次数依赖外层变量时，必须逐圈列表计算，不能简单用 外层×内层。列表法虽然慢，但不会错。
练习题 7（判断题）
题目： 判断下列说法是否正确，正确的打 ✓，错误的打 ×。
① for 循环的三个部分（初始化、条件、更新）都可以省略。（ ）
② 循环嵌套时，内层循环变量会在每次外层循环开始时自动重新初始化。（ ）
③ while(1) 一定是死循环。（ ）
④ continue 语句的作用是结束整个循环。（ ）
⑤ 打印 n 行直角三角形，内层循环体共执行 n(n+1)/2 次。（ ）
🔑 点击查看答案与解析
答案： ① ✓ ② ✓ ③ × ④ × ⑤ ✓
解析：
- ① ✓：for 的三部分都可以省略（但分号不能省），如
for(;;)相当于while(1)； - ② ✓：内层 for 循环的初始化语句（如
int j = 1）每次外层循环都会重新执行，所以 j 会被重置； - ③ ×：
while(1)本身条件恒为真，但如果循环体内有能到达的 break，就不是死循环。死循环的关键是"永远跳不出来"； - ④ ×：continue 只跳过本次循环剩余语句，直接进入下一次判断，循环并没有结束；结束整个循环的是 break；
- ⑤ ✓：直角三角形第 i 行 i 个星，总次数 = 1+2+3+…+n = n(n+1)/2。这是等差数列求和公式，选择题常考。
练习题 8（编程题）
题目： 输入正整数 n，打印 n 行的等腰三角形（用 * 组成）。
输入样例：
4输出样例：
*
***
*****
*******（提示：第 i 行有 2i−1 个星号，前面有 n−i 个空格）
🔑 点击查看答案与解析
参考代码（C++）：
cpp
#include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) { // 外层：n行
// 第1步：打印前面的空格（n-i个）
for (int j = 1; j <= n - i; j++) {
cout << " ";
}
// 第2步：打印星号（2*i-1个）
for (int j = 1; j <= 2 * i - 1; j++) {
cout << "*";
}
// 第3步：换行
cout << endl;
}
return 0;
}
// 输入 4：
// 第1行：3空格 + 1星 → " *"
// 第2行：2空格 + 3星 → " ***"
// 第3行：1空格 + 5星 → " *****"
// 第4行：0空格 + 7星 → "*******"解析要点：
- 等腰三角形 = 空格三角形 + 星号三角形，每行先打印空格再打印星号；
- 第 i 行星号个数 = 2×i−1（奇数递增：1, 3, 5, 7…）；
- 第 i 行前面空格数 = n−i（逐行减少：n-1, n-2, …, 0）；
- 这是嵌套循环的进阶考法——一行里有两个内层循环（先打空格、再打星号）。
💡 图形题万能思路：先分析每行有什么（空格+符号），各有多少个（找规律），然后用内层循环分别打印，最后换行。
九、📊 考点总结表
| 考点 | 重要程度 | 出题形式 |
|---|---|---|
| while 循环三要素（初始化/条件/更新） | ⭐⭐⭐⭐ | 选择/判断/编程 |
| do-while 先执行后判断、至少一次 | ⭐⭐⭐⭐ | 选择/判断 |
| C++ for(初始化;条件;更新) 语法 | ⭐⭐⭐⭐ | 程序填空 |
| 双重循环执行次数（m×n，内层依赖外层要逐圈累加） | ⭐⭐⭐⭐⭐ | 选择/阅读 |
| 图形打印（矩形/三角/倒三角/九九乘法表） | ⭐⭐⭐⭐⭐ | 编程大题 |
| break（跳本层）与 continue（跳本次） | ⭐⭐⭐⭐ | 选择/阅读/编程 |
| 枚举雏形（两数之和、凑硬币/百钱百鸡） | ⭐⭐⭐⭐ | 编程题 |
| 求和/计数/求最值三大套路 | ⭐⭐⭐⭐⭐ | 编程大题 |
| 因子、质数初步判断 | ⭐⭐⭐⭐ | 编程/填空 |
| 死循环成因与 off-by-one 边界错误 | ⭐⭐⭐⭐ | 选择/判断 |
⭐ 必背速记卡
┌─────────────────────────────────────────────────────┐
│ 1. 循环三要素：初始化、条件、更新，缺一不可 │
│ 2. while：先判断后执行，条件为假时最少0次 │
│ 3. do-while：先执行后判断，循环体至少1次 │
│ 4. do-while末尾有分号：while(条件); │
│ 5. for循环：for(初始化;条件;更新)，计数循环首选 │
│ 6. 嵌套循环：外层走一步，内层走一整圈 │
│ 7. 外层控制行，内层控制列，每行结束换行 │
│ 8. 内层次数固定：总次数=外层次数×内层次数 │
│ 9. 内层依赖外层：逐圈累加（如三角形：1+2+…+n） │
│ 10. break：跳出本层循环（急刹车），只跳一层 │
│ 11. continue：跳过本次循环剩余语句（跨水坑） │
│ 12. 求和套路：sum=0，循环中sum+=x │
│ 13. 计数套路：cnt=0，满足条件cnt++ │
│ 14. 求最值套路：打擂法，mx=首值，更大就替换 │
│ 15. 死循环三大因：忘更新、方向反、条件恒真无break │
└─────────────────────────────────────────────────────┘📌 下一章：第 9 章《数学函数》——绝对值、平方根、最值、幂与取整、随机数。