C++ while 与 do-while 循环 完全指南

#include <iostream>
using namespace std;
int main(){
    int i = 5, cntWhile = 0;
    while (i < 5) {        // 条件一开始就为假
        cntWhile++;        // 循环体一次都不执行
    }
    int j = 5, cntDo = 0;
    do {
        cntDo++;           // 先无条件执行一次，再判断条件
    } while (j < 5);
    cout << "while 执行 " << cntWhile << " 次" << endl;
    cout << "do-while 执行 " << cntDo << " 次" << endl;
    return 0;
}
// 实际输出：
// while 执行 0 次
// do-while 执行 1 次

答案：先判断；1。

思路：把两种循环的执行流程摆在一起对比。while 是"判断 → 执行 → 判断 → 执行……"，do-while 是"执行 → 判断 → 执行 → 判断……"。只差第一步的顺序，结果就差很多：初始条件为假时，while 的循环体一次都没碰，do-while 却已经老老实实做完一轮了。

考点：while 与 do-while 的执行流程与语法差别，对应本讲"while 循环"和"do-while 循环"两节。一句话结论：while 可能执行 0 次，do-while 至少执行 1 次。

易错：典型错答是"先执行"或"至少 0 次"，都是把两个循环记反了。另一个高频坑是写 do-while 时漏掉末尾分号——必须写成 do { ... } while(条件);，少一个分号就编译报错。

#include <iostream>
using namespace std;
int main(){
    int i = 10, times = 0;
    while (i > 0) {
        cout << i << " ";
        i -= 3;          // i 的变化：10 → 7 → 4 → 1 → -2
        times++;
    }
    cout << endl;
    cout << "循环执行了 " << times << " 次" << endl;
    return 0;
}
// 实际输出：
// 10 7 4 1
// 循环执行了 4 次

答案：执行 4 次，输出 10 7 4 1。

思路：不要凭感觉数次数，画一张"值变化表"最稳。每轮先判断 i > 0，再输出 i，然后 i 减 3：i = 10（第 1 次）→ 7（第 2 次）→ 4（第 3 次）→ 1（第 4 次）→ -2，此时 i > 0 不成立，循环结束。共 4 次。

考点：while 循环的条件判断时机与循环变量更新，对应"while 循环"和"循环执行次数统计"两节。注意循环次数由"跨过了多少个满足条件的值"决定，不是由起点终点简单相减。

易错：错答"5 次"或"输出到 -2"很常见：前者把 i = -2 那一轮也算进去了（那一轮只在判断处被挡下，循环体没进）；后者忘了条件判断在循环体之前，程序永远不会输出 -2。另外别忘了 i -= 3 必须写在循环体内，否则死循环。

#include <iostream>
using namespace std;
int main(){
    int i = 1, j = 1;
    while (i <= 2) {
        j = 1;                    // 每轮内层都从 1 重新开始
        while (j <= i) {
            cout << j;
            j++;
        }
        cout << endl;
        i++;
    }
    return 0;
}
// 实际输出：
// 1
// 12

答案：两行，第一行 1，第二行 12。

思路：外层变量 i 控制"行"，内层变量 j 控制"每行输出几个数字"。i = 1 时内层 j 从 1 到 1，输出 1；i = 2 时内层 j 从 1 到 2，输出 12。注意内层循环结束时用 endl 换行，所以结果是竖着两行。

考点：嵌套 while 循环的跟踪，对应"嵌套循环"一节。关键点是内层循环变量的初始化和上界都由外层变量决定（这里上界是 i），所以每行长度递增。

易错：最容易错的是把 j = 1 漏掉或写错位置——如果 j 不在外层循环体内重置为 1，第一轮结束后 j = 2，第二轮内层就一次都不执行，结果变成只有一行 "1"。另外 endl 在 while 外面、i++ 之前，别把换行写到循环里，否则会多出空行。

#include <iostream>
using namespace std;
int main(){
    // 格式一：while (条件) { 循环体 }   —— 先判断，后执行
    int i = 1;
    while (i <= 3) {
        cout << i << " ";
        i++;
    }
    cout << endl;
    // 格式二：do { 循环体 } while (条件); —— 先执行，后判断
    int j = 1;
    do {
        cout << j << " ";
        j++;
    } while (j <= 3);
    cout << endl;
    return 0;
}
// 实际输出：
// 1 2 3
// 1 2 3

答案：do-while 格式 do { 循环体 } while(条件);；while 格式 while(条件) { 循环体 }；最大区别：do-while 先执行后判断（至少 1 次），while 先判断后执行（可能 0 次）。

思路：背语法其实是背"判断和执行谁在前"。while 的判断在最前面，所以条件为假时什么都别想执行；do-while 把判断挪到末尾（而且末尾必须跟分号），所以循环体先跑一遍，之后每次判断不是在门口拦人，而是在出口决定"要不要再来一圈"。

考点：两种循环的语法格式与语义差别，对应本讲第一节"while 循环"与第三节"do-while 循环"。这也是后面做"输入密码、最多重试 3 次"这类题目的语法基础。

易错：三个高频错误：① do 后面漏写 while(条件)；② } while(条件) 末尾漏分号；③ 把"至少执行 1 次"答成"至少 0 次"。另外别把 while 的条件写成分号结尾（while(条件);），那会让循环体变成空语句，程序直接死循环。

#include <iostream>
using namespace std;
int main(){
    int i = 1, j = 1;
    while (i <= 3) {
        j = 1;                        // 内层变量每轮重置为 1
        while (j <= 3) {
            cout << i << "," << j << " ";
            j++;
        }
        cout << "|";                  // 每行结束后打一个分隔符
        i++;
    }
    cout << endl;
    return 0;
}
// 实际输出：1,1 1,2 1,3 |2,1 2,2 2,3 |3,1 3,2 3,3 |

答案：1,1 1,2 1,3 |2,1 2,2 2,3 |3,1 3,2 3,3 |

思路：外层 i 从 1 走到 3，内层 j 每次都从 1 走到 3。熟练以后可以直接用"组合计数"：外层 3 轮 × 内层 3 轮 = 9 对数字，按 i 从小到大、j 从小到大排列即可，不用一格格硬推。

考点：双重循环的遍历顺序，对应"嵌套循环"一节，也是后面枚举、二维图案打印的基础。核心结论：外层走 M 步、内层走 N 步，内层循环体共执行 M × N 次。

易错：① 忘了 j = 1 重置，第二轮开始内层不执行，输出会缺一大半；② 把 cout << "|" 写进内层循环，分隔符会变成每对数字后面都跟一个；③ 用 endl 代替 "|" 会让 9 对数字变成 9 行，和题目的分隔符效果不一致。

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    int i = 1;
    long long fact = 1;
    while (i <= n) {
        fact *= i;
        i++;
    }
    cout << "fact = " << fact << endl;
    int zeros = 0;
    while (fact % 10 == 0) {
        zeros++;
        fact /= 10;
    }
    cout << "末尾零的个数 = " << zeros << endl;
    return 0;
}

思路：先用 while 循环连乘求出 n!，再用 while 反复去掉末位的 0 来数出个数。

易错：用 int 存阶乘会溢出（20! 就超过 int 范围）；把「多少个 0」理解成全部数字中 0 的个数，而不是末尾连续零的个数。

#include <iostream>
using namespace std;
int main(){
    int i = 1;
    while (i <= 10) {
        if (i == 5) break;     // i=5 时立即跳出整个 while
        cout << i << " ";
        i++;
    }
    cout << "done" << endl;
    return 0;
}
// 实际输出：1 2 3 4 done

答案：1 2 3 4 done

思路：沿着 i = 1,2,3,4 走，每轮都满足 i == 5 吗？不满足，所以正常输出。走到 i = 5 时，if 条件成立，break 执行，循环立刻结束——注意 break 之后的那行输出和 i++ 都不会执行，程序跳到循环后面继续跑，于是接着打印 done。

考点：break 语句的作用范围，对应本讲"break 与 continue"一节。break 结束的是离它最近的那一层循环，循环后面的代码照常继续执行。

易错：① 错答成 1 2 3 4 5 done——把 i = 5 也输出了一遍，其实 break 在输出之前就跳走了；② 错答成 1 2 3 4——以为 break 会让整个程序结束，其实它只跳出循环，后面的 cout << "done" 仍然会执行（那要 return 或 exit 才能做到）；③ 把 break 和 continue 弄混：continue 只会跳过本轮剩下的部分，循环还会继续。

考点：continue 只结束本次循环、进入下一次条件判断，而 break 才跳出整个循环。

易错：把 continue 当成 break 使用，以为它能提前结束循环。

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    int a[100][100] = {0};
    int i = 1;
    while (i <= n) {
        int j = 1;
        while (j <= i) {
            if (j == 1 || j == i) {
                a[i][j] = 1;
            } else {
                a[i][j] = a[i-1][j-1] + a[i-1][j];
            }
            cout << a[i][j] << " ";
            j++;
        }
        cout << endl;
        i++;
    }
    return 0;
}

思路：用二维数组一行一行构造，每行首尾固定为 1，中间元素由上一行相邻两数相加得到。

易错：数组初值没清零导致中间元素带脏数据；内层循环边界写成 j < i 会漏掉行末的 1。

#include <iostream>
using namespace std;
int main(){
    int n;
    cin >> n;
    int count = 0;
    int i = 1;
    while (i <= n) {
        int temp = i;
        bool hasOne = false;
        while (temp > 0) {
            if (temp % 10 == 1) {
                hasOne = true;
                break;
            }
            temp /= 10;
        }
        if (hasOne) count++;
        i++;
    }
    cout << "1到" << n << "中包含1的数有 "
         << count << " 个" << endl;
    return 0;
}

思路：外层枚举 1~N，内层用 % 10 逐位检查是否出现数字 1，一旦找到就跳出内层。

#include <iostream>
#include <string>
using namespace std;
int main(){
    string password;
    int attempts = 0;
    bool success = false;
    do {
        cout << "请输入密码：";
        cin >> password;
        attempts++;
        if (password == "123456") {
            success = true;
            break;
        }
        cout << "密码错误！剩余机会："
             << (3 - attempts) << endl;
    } while (attempts < 3);
    if (success) {
        cout << "登录成功！" << endl;
    } else {
        cout << "账户已锁定！" << endl;
    }
    return 0;
}

思路：用 do-while 先让用户输入再判断，配合 attempts 计数和 success 标志控制最多试三次。

易错：用普通 while 先判断条件，导致一次密码都没输入就退出；次数判断写成 < 3 会少给一次机会。

#include <iostream>
using namespace std;
int main(){
    int a, b;
    cin >> a >> b;
    int x = a, y = b;
    while (y != 0) {
        int t = y;
        y = x % y;
        x = t;
    }
    cout << "GCD(" << a << ", " << b
         << ") = " << x << endl;
    return 0;
}

思路：用辗转相除法，每轮把除数变成新的被除数、余数变成新的除数，直到余数为 0。

易错：直接对 a、b 操作会破坏原值，最后无法输出原数；取余前没保证除数不为 0 会导致除以零。