第四章 流程控制结构

第四章 流程控制结构

一、项目引入-猜数字游戏

1.1 先看成品

先看写完之后长什么样。答案先固定成 42，随机数留到 3.6 节。

#include <iostream>
using namespace std;

int main() {
    int answer = 42;
    int guess = 0;
    int count = 0;

    while (guess != answer) {
        cout << "猜一个 1 到 100 的数: ";
        cin >> guess;
        count++;

        if (guess > answer) {
            cout << "猜大了" << endl;
        } else if (guess < answer) {
            cout << "猜小了" << endl;
        } else {
            cout << "猜中了，一共猜了 " << count << " 次" << endl;
        }
    }
    return 0;
}

跑起来是这个节奏。

猜一个 1 到 100 的数: 50
猜大了
猜一个 1 到 100 的数: 25
猜小了
猜一个 1 到 100 的数: 37
猜小了
猜一个 1 到 100 的数: 44
猜大了
猜一个 1 到 100 的数: 40
猜小了
猜一个 1 到 100 的数: 42
猜中了，一共猜了 6 次

这个猜法有章法，先砍一半，再砍一半，六次收工。1 到 100 的范围，二分查找最多七次，这是算得出来的，二的七次方是一百二十八，装得下一百个可能。程序该干的事它都干了，读输入、比大小、报结果，猜中了自动停。注意两个细节，循环不知道要跑多少轮，猜中才停；每轮说的话不一样，看猜的数是大是小。这两件事，一个靠循环，一个靠选择。

┌──────────────────────────────────────────────────────────┐
│ 猜数字游戏走这几步                                       │
├──────────────────────────────────────────────────────────┤
│ 先想数，再循环猜，猜中了才结算                           │
│                                                          │
│ ┌────────────────────────────────────────────────────┐   │
│ │  开局      埋随机种子，生成 1 到 100 的一个数      │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  进循环    提示玩家输入，读进一个整数              │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  比大小    猜大了、猜小了、猜中了，三条路          │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  跳出结算  报告猜了几次，程序收工                  │   │
│ └────────────────────────────────────────────────────┘   │
│                                                          │
│   猜大猜小都不退循环，接着提示，直到猜中为止             │
│   次数靠一个计数器，每猜一次加一                         │
└──────────────────────────────────────────────────────────┘

1.2 拆开看，就三样东西

把这段程序按行拆开，用到的知识摊开就这几样。

段落	代码里的样子	属于哪一块
准备	answer guess count 三个变量	第二章的老本
反复猜	while 加一个条件	循环结构
分岔提示	if else if 三分支	选择结构
猜中收工	条件变假，循环自己退	循环的出口

前两章的东西这一章全用得上。cin 读数，第二章学的变量累加，第三章学的输出格式化，都是现成的。真正新加的只有两样，选择结构和循环结构。这一章的正文就讲这两块，最后合起来，就是开头那个游戏。

选择结构回答的是该走哪条路。猜大了走大的提示，猜小了走小的提示，猜中了走结算。循环结构回答的是这件事要做几遍。读数、比较、提示，这一套要重复到猜中为止，写几遍都不对，要写成一个会自己转的圈。

1.3 没有流程控制之前

回头看表哥那十来个 if。他把程序写成了清单，猜 50 做什么，猜 51 做什么，一条条列。清单的问题在于长度固定，而游戏的长度不固定。有人五次猜中，有人六十次猜中，清单写不到那么长。

流程控制和清单的差别在这一点上。清单是照着走，走完拉倒；流程控制是会看情况，情况不变就接着转。while 那一行，条件是真的就再转一圈，是假的就出门，转几圈由玩游戏的人决定，不由写程序的人决定。

猜数字是个好教具。它够小，四十行，一下能看完；它也够全，选择、循环、跳转、输入输出全用上了。这一章把它拆开讲，下一章再把它拼回去。

二、选择结构

2.1 条件的积木

if 后面挂的是一个条件，条件由关系运算符和逻辑运算符搭出来。

关系运算符六个，都是老熟人。

运算符	念法	例子	结果
<	小于	3 < 5	真
大于		3 > 5	假
<=	小于等于	5 <= 5	真
>=	大于等于	5 >= 6	假
==	等于	5 == 5	真
!=	不等于	5 != 5	假

等于号是两个等号。一个等号是赋值，把右边的值塞进左边的变量，第二章说过。写成 if (x = 0) 是先把 x 改成 0，再拿 0 当条件，永远是假，这是新手头号事故，编译器多半还会补一个警告。

逻辑运算符三个，负责把多个条件拼起来。

运算符	含义	例子
&&	并且，两边都真才真	年龄够并且有余票
||	或者，一边真就真	是会员或者是学生
!	取反，真变假	不是空

判断一个数在 1 到 100 之间，要写两个条件用 && 连。

if (x >= 1 && x <= 100) {
    cout << "在范围内" << endl;
}

数学里 1 <= x <= 100 这么写很顺，C++ 里不行。运算从左往右，先算 1 <= x 得 0 或 1，再拿这个 0 或 1 去和 100 比，结果永远是 1，条件恒真。这个坑第三章踩过一次，混合比较翻车，同一个道理。

优先级上，关系运算符比逻辑运算符高，&& 比 || 高。拿不准就加括号，括号不要钱，还能让读代码的人少费脑子。

2.2 if 的三种形态

一个 if 有三种长法，分支一个比一个多。

┌────────────────────────────────────────────────────────┐
│ if 的三种形态                                          │
├────────────────────────────────────────────────────────┤
│ 一个 if，三种长法，分支越来越多                        │
│                                                        │
│ +--------------+------------------+----------------+   │
│ |形态          |长相              |什么时候用      |   │
│ +--------------+------------------+----------------+   │
│ |单分支        |if 加花括号       |条件成立才做    |   │
│ |双分支        |if 配 else        |二选一          |   │
│ |多分支        |if else if 链     |三个以上候选    |   │
│ +--------------+------------------+----------------+   │
│                                                        │
│   if 后面挂条件，成立进花括号，不成立跳过去            │
│   else 贴着上一个 if，中间别插别的语句                 │
└────────────────────────────────────────────────────────┘

单分支，条件成立才做，不成立就跳过去。

if (score >= 60) {
    cout << "及格了" << endl;
}

双分支，二选一，总有一边要执行。

if (num % 2 == 0) {
    cout << "偶数" << endl;
} else {
    cout << "奇数" << endl;
}

多分支，一串 if else if 挂下来，从第一个条件开始试，哪个中了走哪条。

if (score >= 90) {
    cout << "优" << endl;
} else if (score >= 80) {
    cout << "良" << endl;
} else if (score >= 60) {
    cout << "中" << endl;
} else {
    cout << "差" << endl;
}

这段代码有个顺序讲究。判断从大到小排，先问是不是优，不是再问良。写成从小到大就全乱，60 分先被中接走，90 分永远摸不到优的门。多分支的条件，谁严谁先。

else 配对是另一个事故点。else 找的是离它最近的、还没配对的 if。缩进好看不等于逻辑好看，下面这段看着是两层，其实是一层。

if (x > 0)
    if (y > 0)
        cout << "第一象限" << endl;
else
    cout << "x 不是正数" << endl;

编译器眼里，那个 else 属于内层 if。x 是负数的时候，内层 if 压根没执行，else 也没机会执行，屏幕干干净净。解决办法是花括号一律写上，哪怕只有一句话。这不是风格问题，是保命。

if (x > 0) {
    if (y > 0) {
        cout << "第一象限" << endl;
    }
} else {
    cout << "x 不是正数" << endl;
}

嵌套 if 的真实用例是二维判断。先分性别，再分年龄段，一层套一层，每层管一个维度。层数最多两层，三层以上就该换成 switch 或者查表，人读不动。

2.3 条件运算符

有一个场景很常见，两个值里挑大的。用 if else 写，先声明再摆一个判断，啰嗦。

int max;
if (a > b) {
    max = a;
} else {
    max = b;
}

条件运算符一行搞定，它是唯一的三目运算符，三个位置各就各位。

int max = (a > b) ? a : b;

问号前面是条件，真走问号后面，假走冒号后面。括号建议一直带着，它的优先级低得反常，混进复杂表达式里容易和赋值号搅在一起。这句话也说给自己，Debug 打多了就知道，一行能装下的聪明，常常是三天后看不懂的伏笔。

2.4 switch 与穿透

分支超过三个，if else if 链就开始显长。switch 是为这种场合生的，拿着一个值去对一堆标签。

int level = 2;
switch (level) {
    case 1:
        cout << "初级" << endl;
        break;
    case 2:
        cout << "中级" << endl;
        break;
    case 3:
        cout << "高级" << endl;
        break;
    default:
        cout << "等级不明" << endl;
}

执行的时候先看 switch 后面挂的值，这里是 2。从上往下找标签，找到 case 2，从那一行开始执行，打印中级，碰上 break，跳出 switch。default 是兜底，没有一个 case 对上的时候归它，写不写都行，建议写。

┌──────────────────────────────────────────────────────────┐
│ switch 是怎么跑的                                        │
├──────────────────────────────────────────────────────────┤
│ switch 拿着值去对标签，对上了从那儿开始跑                │
│                                                          │
│ ┌────────────────────────────────────────────────────┐   │
│ │  对标签    值等于哪个 case 的常量，就从哪行起跑    │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  往下顺    没有 break 就一条条掉下去，这叫穿透     │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  break     当场跳出 switch，后面的 case 不看       │   │
│ └────────────────────────────────────────────────────┘   │
│                                                          │
│   每个分支末尾都该有 break，忘了就是穿透事故             │
│   case 只能对整数，范围题交给 if else if                 │
└──────────────────────────────────────────────────────────┘

break 是这套机制里最容易忘的东西。忘了会怎样，看一眼穿透事故。

int level = 1;
switch (level) {
    case 1:
        cout << "初级" << endl;
    case 2:
        cout << "中级" << endl;
    case 3:
        cout << "高级" << endl;
    default:
        cout << "等级不明" << endl;
}

输入 1，屏幕上四行全出来了。case 1 执行完没有东西拦着，顺着掉进 case 2，再掉进 case 3，最后连 default 一起执行。这个行为叫穿透，标准规定如此，不是编译器抽风。有些场合故意用它，几个 case 共享一段代码，日常多数是忘写。判断标准很简单，写的时候有没有想过要穿透，没想过就是忘了。

switch 的规矩还有几条，都是硬性的。

规矩	说明
只能对整数	int char 枚举都行，字符串不行
标签是常量	case 后面跟编译期定得下的数，不能是变量
标签不重复	两个 case 1，编译直接拦
default 随便放	放头放尾都行，习惯放最后

分支多且值是整数，用 switch；条件带范围，比如判断优良好中差，用 if else if。switch 对范围没有天赋，case 后面写 >= 90 直接编不过。

三、循环结构

3.1 while 先判后跑

while 的规矩一句话，条件是真的，身体就再跑一遍，每跑完一遍重新问一次。

int i = 1;
while (i <= 5) {
    cout << i << endl;
    i++;
}

屏幕上出来 1 到 5。注意 i++ 那一行，它让条件有变化。去掉它，i 永远是 1，条件永远为真，程序永远跑下去，这就是死循环。

死循环的样子很吓人，屏幕刷到看不见光标， Ctrl+C 按下去才停。第一次见容易慌，慌可以，别直接关窗口，死循环是本章必修课，见一次修一次就长记性。

最常见的死循环病根有两个。一个是条件里写赋值，while (flag = 1) 每次进来先把 flag 设成 1，再拿 1 当条件，恒真。编译器会给警告，大意是建议加括号确认是不是赋值，看见这个警告就当错误处理。另一个是忘了更新，计数器不走了，条件不动了，圈就不停了。

int flag = 1;
while (flag = 1) {   // 赋值，不是比较，恒真
    cout << "停不下来" << endl;
}

while 有个兄弟叫 do while，俩人的差别在先后。

┌──────────────────────────────────────────────────────┐
│ while 和 do while 差在哪                             │
├──────────────────────────────────────────────────────┤
│ 两种循环，判条件和跑身体的先后反过来                 │
│                                                      │
│ +--------------+----------------+----------------+   │
│ |循环          |先干什么        |身体最少跑几次  |   │
│ +--------------+----------------+----------------+   │
│ |while         |先判条件        |可能一次都不跑  |   │
│ |do while      |先跑身体        |至少跑一次      |   │
│ +--------------+----------------+----------------+   │
│                                                      │
│   循环进门先后不同，空转的表现就不同                 │
│   do while 的分号是语法，漏了报错位置发懵            │
└──────────────────────────────────────────────────────┘

3.2 do while 先跑后判

do while 把身体提到前头，条件挪到后头。翻译成人话，先跑一遍，再问还要不要跑。

int choice;
do {
    cout << "1 开始 2 设置 0 退出" << endl;
    cout << "选一个: ";
    cin >> choice;
} while (choice != 0);

菜单用 do while 正合适。菜单至少得显示一次，while 先问后跑，条件凑不巧就一次不显示，do while 没这个问题。输 0 退出，输别的继续显示，逻辑顺。

两条使用规矩。分号不能省，while (choice != 0); 这个分号是语法的一部分，漏了编译报错，报的位置还容易看懵。花括号里的身体和 while 是绑定的，break 一样管用。

三种循环的分工，一句话版本。次数知道用 for，次数看情况用 while，至少跑一次用 do while。

循环	判条件时机	身体最少几次	典型场合
while	进圈之前	可能零次	猜数字、读文件到结尾
do while	跑完之后	至少一次	菜单、重试询问
for	每轮之前	可能零次	计数、遍历、九九乘法表

3.3 for 为计数而生

while 什么圈都能转，计数的圈转起来啰嗦。定起点，判终点，往前迈一步，三件事摊在 while 里是这个样子。

int i = 1;
while (i <= 100) {
    cout << i << endl;
    i++;
}

for 把这三件事收进一行，一格放一样。

for (int i = 1; i <= 100; i++) {
    cout << i << endl;
}

┌────────────────────────────────────────────────────────┐
│ for 的三段各管什么                                     │
├────────────────────────────────────────────────────────┤
│ for 的三个格子各管一段，分号是格子之间的墙             │
│                                                        │
│ +------------+----------------------+--------------+   │
│ |格子        |管什么                |跑几次        |   │
│ +------------+----------------------+--------------+   │
│ |初始化      |定计数器的起点        |只跑一次      |   │
│ |条件        |决定还跑不跑          |每轮都跑      |   │
│ |更新        |计数器往前走一步      |每轮都跑      |   │
│ +------------+----------------------+--------------+   │
│                                                        │
│   三段都能省，分号不能省，省光就是死循环               │
│   计数器习惯用 i，嵌套里层用 j，别重用                 │
└────────────────────────────────────────────────────────┘

执行顺序得盯一眼。初始化只来一次，条件每轮都问，更新每轮都跑，三个格子的节奏不一样。

┌──────────────────────────────────────────────────────────┐
│ 一轮 for 按什么顺序走                                    │
├──────────────────────────────────────────────────────────┤
│ 一轮循环里，条件和更新隔着身体打招呼                     │
│                                                          │
│ ┌────────────────────────────────────────────────────┐   │
│ │  初始化    进屋前做一次，定好起点                  │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  判条件    真的往下走，假的出门                    │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  跑身体    该做的事写在这儿                        │   │
│ └────────────────────────────────────────────────────┘   │
│                           │                              │
│                           v                              │
│ ┌────────────────────────────────────────────────────┐   │
│ │  更新      计数器加一，再回去判条件                │   │
│ └────────────────────────────────────────────────────┘   │
│                                                          │
│   顺序是先判后跑再更新，更新完回到判断                   │
│   多跑一轮，多半是判断写成了小于等于                     │
└──────────────────────────────────────────────────────────┘

初学者最常栽在边界上。打印 1 到 10，条件写成 i <= 10 对，写成 i < 10 少一个，写成 i <= 11 多一个。拿不准的时候小刀割一下，先跑个 1 到 3，数一数，再放回去跑 1 到 100。多跑一轮少跑一轮的毛病，十个循环 bug 里占三个。

for 的三段都能省，分号不能省。省一段常见于计数器在别处初始化，省两段也有人写，三段全省就是 for (;;)，和 while (true) 一个意思，死循环的正式写法。

for (int i = 0, j = 10; i < j; i++, j--) {
    cout << i << " " << j << endl;
}

这一段用了逗号表达式，初始化和更新各干两件事，两头往中间走，碰头为止。算是个花活，知道有就行，日常代码里见到的机会不多。

还有一条常考细节。for 里声明的变量，活动范围就在这个 for 里，出了圈就没了。C++ 一向是这样，C 语言要到 C99 才跟上，所以老代码里常见先声明再用的写法，两种都看得懂就行。

3.4 break 和 continue

圈里想提前撤，用 break。圈里想跳过这一轮，用 continue。两个都是本章的关键词，去的地方不一样。

┌────────────────────────────────────────────────────────┐
│ break 和 continue 的去向                               │
├────────────────────────────────────────────────────────┤
│ 两个跳语句，跳的高度不一样                             │
│                                                        │
│ +--------------+--------------------+--------------+   │
│ |语句          |跳去哪              |循环还跑吗    |   │
│ +--------------+--------------------+--------------+   │
│ |break         |直接出循环          |不跑了        |   │
│ |continue      |回条件判断          |接着跑下一轮  |   │
│ +--------------+--------------------+--------------+   │
│                                                        │
│   break 在 switch 里也认，跳出这一层 switch            │
│   嵌了两层循环，break 只跳最近的那一层                 │
└────────────────────────────────────────────────────────┘

看代码。1 到 10 挨个打，碰上 5 跳过，碰上 8 收工。

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        continue;
    }
    if (i == 8) {
        break;
    }
    cout << i << endl;
}

屏幕上挨个出来 1 2 3 4 6 7，六个数字。continue 跳的是本轮剩下的语句，跳完回到更新那一格，计数器照走；break 是整个圈不要了，更新都不回去。

break 只跳最近的一层，这个限定词别丢。想从里层一下撤到最外面，break 不帮忙，得靠一个标记变量加条件判断，那是后话，函数和返回值会给出更干净的解法。

3.5 嵌套循环与九九乘法表

圈里套圈，就是嵌套循环。外层走一步，内层跑一整轮，这个节奏是理解嵌套的唯一钥匙。

┌──────────────────────────────────────────┐
│ 嵌套循环谁先跑                           │
├──────────────────────────────────────────┤
│ 外层走一步，内层要跑完一整轮             │
│                                          │
│   外层 i 从 1 到 9，每走一步             │
│       │                                  │
│       v                                  │
│   内层 j 从 1 到 i，整整齐齐跑完         │
│       ├─ i 是 1 的时候，j 只跑 1 轮      │
│       ├─ i 是 9 的时候，j 跑 9 轮        │
│       └─ 总共 45 个等式，一行比一行长    │
│                                          │
│   内层跑完，外层才更新，不是同时往前跑   │
│   看不清的时候，两个计数器都打印出来看   │
└──────────────────────────────────────────┘

九九乘法表是嵌套循环的保留节目。九行，第一行一个等式，第九行九个，一共四十五个。用循环写，外层管行，内层管列。

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        cout << j << "x" << i << "=" << i * j << "\t";
    }
    cout << endl;
}

内层的条件是 j <= i，不是 j <= 9。就这一个小于等于，决定了第一行只有一个等式，第九行有九个。改成 j <= 9，出来的是方阵，一行不落，三角形摊成正方形，能跑，但不是要的那个。

外层循环体里就两件事，内层循环加一个换行。内层负责把一行填满，外层负责换下一行。套第三层不是不行，是很少有人读得动，两层是人的舒适区上限。

嵌套循环最容易出的 bug 是计数器写重。两层都用 i，内层一轮把外层的 i 搅得天翻地覆，圈数全乱。规矩是外层 i 内层 j，第三层才轮到 k，别省这点字母。

3.6 随机数与完整版

固定答案 42 的游戏玩第二轮就没意思了，答案得会变。变之前先知道，计算机里的随机是假随机，由数学公式一批批算出来，起点相同算出来的一串数完全相同。

rand 函数从 <cstdlib> 来，每次调用给一个数，范围 0 到 RAND_MAX。RAND_MAX 是个常量，标准只要求不小于 32767，Windows 上常见就是 32767，Linux 和 macOS 上常是二十多亿。不播种，每次运行 rand 吐的数一个样，程序昨天今天一个答案。

srand 负责播种，配 time 拿当前时刻当种子，每次跑都不一样。

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main() {
    srand((unsigned int)time(nullptr));
    for (int i = 0; i < 5; i++) {
        cout << rand() << endl;
    }
    return 0;
}

跑两遍，数字不一样了。要 1 到 100，取余再平移，rand % 100 + 1，取余得 0 到 99，加 1 得 1 到 100。

C++11 起有了新玩具，<random> 头文件，随机数引擎加分布，两行搞定，分布更均匀，写法也更直白。

#include <iostream>
#include <random>
using namespace std;

int main() {
    random_device rd;
    mt19937 rng(rd());
    uniform_int_distribution<int> dist(1, 100);

    for (int i = 0; i < 5; i++) {
        cout << dist(rng) << endl;
    }
    return 0;
}

初学者建议先认 rand 那一套，老代码里到处都是，读得懂才有然后。<random> 是写新代码的选择，等哪天要均匀分布、要正态分布、要可复现的随机序列，再回来细聊。

做法	头文件	一句话点评
rand 加 srand	<cstdlib> 加 <ctime>	老搭档，教程和遗产代码都靠它
mt19937 加分布	<random>	现代做法，均匀可控，该早点换

现在拼完整版。五摊东西，埋种子、生成答案、循环猜、计数器、结算。

┌────────────────────────────────────────────────────────┐
│ 猜数字程序分五摊                                       │
├────────────────────────────────────────────────────────┤
│ 完整版还只有一个 main，里面分了五摊                    │
│                                                        │
│ +------------+----------------------+--------------+   │
│ |段落        |干什么                |用到什么      |   │
│ +------------+----------------------+--------------+   │
│ |埋种子      |让每次运行答案不同    |srand 加 time |   │
│ |生成答案    |定一个 1 到 100 的数  |rand 加取余   |   │
│ |循环猜      |读、比、提示，猜中才停|while 加 if   |   │
│ |计数器      |记猜了几次            |一个 int      |   │
│ |结算        |跳出后报告成绩        |break 跳这儿  |   │
│ +------------+----------------------+--------------+   │
│                                                        │
│   五摊按顺序排，循环那块是本章的组合拳                 │
│   拆函数留到下一章，现在先堆在 main 里                 │
└────────────────────────────────────────────────────────┘

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main() {
    srand((unsigned int)time(nullptr));
    int answer = rand() % 100 + 1;
    int guess = 0;
    int count = 0;

    while (guess != answer) {
        cout << "猜一个 1 到 100 的数: ";
        cin >> guess;
        count++;

        if (guess > answer) {
            cout << "猜大了" << endl;
        } else if (guess < answer) {
            cout << "猜小了" << endl;
        } else {
            cout << "猜中了，一共猜了 " << count << " 次" << endl;
        }
    }
    return 0;
}

和 1.1 节的差别只有两行，一个 srand，一个 rand % 100 + 1。流程一行没动，这就是流程控制值钱的地方，壳子搭好，换内容只是换两行。

顺手指出一个脆弱处。cin 里喂个字母，第三章讲过，failbit 一置，cin 直接摆烂，guess 再也不更新，循环停不下来。交差之前先用字母试一次，崩了就知道要补第三章那套三板斧。

四、小结

┌──────────────────────────────────────────────────────────┐
│ 本章收口                                                 │
├──────────────────────────────────────────────────────────┤
│ 一章学完，手上就该有这几样东西                           │
│                                                          │
│ ┌────────────────────────────────────────────────────┐   │
│ │  选择      if 三形态，switch 加 break              │   │
│ └────────────────────────────────────────────────────┘   │
│ ┌────────────────────────────────────────────────────┐   │
│ │  循环      while、do while、for 各就各位           │   │
│ └────────────────────────────────────────────────────┘   │
│ ┌────────────────────────────────────────────────────┐   │
│ │  跳转      break 跳出，continue 跳过本次           │   │
│ └────────────────────────────────────────────────────┘   │
│                                                          │
│   猜数字一个游戏，把选择、循环、跳转全用上了             │
│   读代码先找循环，再看循环里的分支                       │
│   下一章把 main 里这五摊收进函数                         │
└──────────────────────────────────────────────────────────┘

知识	一句话	最容易栽在哪
if 三形态	单双多，分支一个个加	条件顺序写反
else 配对	找最近的没配对 if	缩进骗人，花括号救命
switch	整数对标签，break 跳出	忘 break 全穿透
while	先判后跑	条件恒真，忘了更新
do while	先跑后判，至少一次	漏分号
for	三段一格，计数专用	边界小于等于
break	出圈	嵌套里只跳一层
continue	跳过本轮	更新不走就死循环
嵌套循环	外层一步内层一轮	计数器重用
随机数	先播种再 rand	不播种答案不变

五句话带走。流程控制不是新语法，是把程序的走法从直线变成会看路。选择看条件，循环看真假，跳转让走法更利索。if 的花括号一律写上，这是本章性价比最高的一条。猜数字一个游戏把全章的关键字用全了，读它三遍胜过读三十个片段。写死循环别慌， Ctrl+C 加检查条件，两步搞定。

课后练习四道，由易到难。改猜数字，加次数上限，七次没中就报答案是几，重开一轮。九九乘法表倒过来打，第九行九个等式第一行一个。打印 100 以内的素数，用取余判一遍，break 提前收工。写个菜单，用 do while 包着，选 0 才退出，选错给提示。

附录｜流程控制速查卡

类别	关键词	一句话提醒
单分支	if 加花括号	条件真才进
双分支	if 配 else	二选一必执行
多分支	if else if 链	严条件放前面
三目	条件 ? 甲 : 乙	一行二选一，加括号
多路开关	switch case default	标签是整数常量，break 别忘
先判循环	while	条件假一次不进
先跑循环	do while	至少一次，分号别省
计数循环	for	三段一格，分号不能省
跳出	break	switch 里也认，只跳一层
跳过	continue	回条件判断，不走完本轮

常见现象	病根	药方
程序停不下来	条件恒真或没更新	查赋值号，查计数器
屏幕刷到看不清	死循环在打印	Ctrl+C，先停再查
多跑或少跑一轮	边界写成小于等于	先跑三轮数一数
switch 分支全执行	忘了 break	每个 case 补上
else 对不上号	缩进骗人	花括号写上
内层循环不跑	内层条件一开始就假	两个计数器都打印
每次运行答案一样	忘了 srand	开头埋种子
喂字母程序卡死	failbit 没清	clear 加 ignore 重问