目录
1.3.6 案例：计算 100 以内（包括 100）所有数字的和
2.3.5 案例：计算 100 以内（包括 100）所有数字的和
4.4.5 案例：计算 100 以内（包括 100）所有数字的和
在 C 语言中，循环语句是一种控制流语句，它允许重复执行一段代码多次，直到满足某个条件为止。循环语句在编程中非常有用，特别是当需要重复执行某项任务，但每次执行时可能处理的数据或条件略有不同时。C 语言提供了多种循环语句，每种都有其特定的用途和语法。
1 while 循环
1.1 基本语法
while (循环条件表达式)
{
循环体语句;
}当循环条件表达式成立，就执行循环体语句，直到条件不成立停止循环，即先判断再执行。
为避免死循环，循环条件表达式不能永远成立，且随着循环次数增加，应该越来越趋向于不成立。
1.2 流程图
1.3 计数循环
1.3.1 实现原则
在 C 语言中使用 while 实现计数循环时需要遵循以下三个基本原则：
1. 必须初始化循环变量
在进入while 循环之前，必须首先为循环变量赋予一个初始值。这个初始值通常是计数循环的起点。例如，如果你想要从 1 数到 10，你就需要在循环开始前将循环变量（比如命名为 count）初始化为 1。这个初始化确保了循环有一个明确的起点，从而可以按照预定的方式开始计数。
2. 循环变量比较作为循环条件
while 循环的循环条件是一个布尔表达式，它决定了循环是否应该继续执行。在计数循环中，这个条件通常涉及对循环变量的比较。例如，你可能想要一直执行循环体，直到循环变量达到或超过某个特定值。因此，循环条件可能类似于 count <= 10，这意味着只要 count 的值小于或等于 10，循环就会继续。这个条件确保了循环按照预定的次数执行。
3. 循环变量变化
在循环体的末尾（或在循环体的某个地方，但必须在下一次迭代之前），必须更新循环变量的值。这通常是通过增加或减少循环变量（假设为 count）的值来实现的，具体取决于你的计数方向（向上计数还是向下计数）。我们可以通过 count++（即 count = count + 1）来更新循环变量的值的。这个更新步骤是必不可少的，因为它确保了每次循环迭代后，循环条件都会被重新评估，并且如果条件仍然为真，则循环将继续执行。如果循环变量没有变化，循环将无限期地继续执行，这通常被称为 “无限循环”或 “死循环”，是编程中需要避免的情况，除非真的需要用到死循环。
1.3.2 案例：循环输出语句
使用 while 循环实现：输出10次 "我第n天吃了n个韭菜馅的包子"。
#include <stdio.h>
int main()
{
// 定义循环变量，初始化为 0，表示从第 0 天开始计数
// 但通常我们从第 1 天开始计数，所以这里实际上会输出从第 0 天到第 9 天的信息
int num = 0;
// 开始循环，条件是 num 小于 10。
// 这意味着循环将执行直到 num 达到 10 为止（但不包括 10），即循环 9 次
while (num < 10)
{
printf("我第%d天吃了%d个韭菜馅的包子 \n", num, num);
// 循环标记变量变化，每次循环结束时 num 的值增加 1，为下一次循环准备条件
num++;
}
// 循环结束后，打印循环变量的值。由于循环条件是 num < 10，循环结束时 num 的值将是 10
printf("循环结束后循环变量的值：%d", num);
return 0;
}输出结果如下所示：
注意：如果希望输出从 “我第1天吃了1个...” 到 “我第10天吃了10个...”，则应该将 num 的初始值设置为 1，并且循环条件改为 num <= 10
1.3.3 案例：循环输出数字 7~15
#include <stdio.h>
int main()
{
// 初始化循环变量 n 为 7，准备从 7 开始循环输出数字
// 这是循环的起始点
int n = 7;
// 开始 while 循环，条件是 n 小于或等于 15。
// 这意味着循环将一直执行，直到 n 增加到 16 为止
while (n <= 15)
{
printf("%d \n", n);
// 更新循环变量 n 的值，使其增加 1，为下一次循环迭代做准备
n++;
}
// 当循环结束后（即 n 增加到 16 时），打印循环变量的最终值
printf("循环结束后循环变量的值：%d", n);
return 0;
}输出结果如下所示：
1.3.4 案例：倒序输出数字 56 ~ 43
#include <stdio.h>
int main()
{
// 初始化循环变量 i 为 56，作为倒序输出的起始点，准备从 56 开始倒序输出数字
int i = 56;
// 开始 while 循环，条件是 i 大于等于 43。这意味着循环将一直执行，直到 i 减小到 42 为止
while (i >= 43)
{
printf("%d \n", i);
// 更新循环变量 i 的值，使其减小 1，为下一次循环迭代做准备
i--;
}
// 当循环结束后（即 i 减小到 42 时），打印循环变量的最终值
printf("循环结束后循环变量的值：%d", i);
return 0;
}输出结果如下所示：
1.3.5 案例：输出 10（包括 10）以内所有的偶数
#include <stdio.h>
int main()
{
// 1. 通过控制循环变量来打印偶数（从 0 到 10，包括 0）
// 这种方法直接在循环体内部修改循环变量i的值，从而避免不必要的循环迭代，提高效率
int i = 0; // 初始化循环变量
while (i <= 10) // 循环条件，保证打印到 10（包括 0）
{
printf("%d\t", i);
i += 2; // 循环变量自增 2，以跳过奇数，只打印偶数
}
printf("\n循环结束后循环变量的值：%d", i); // 此时 i 为 12（超过 10 后退出循环）
printf("\n");
// 2. 通过判断奇偶来打印偶数（从 0 到 10，包括 0）
// 此方法通过条件判断来区分奇偶，然后决定是否打印
int j = 0; // 初始化循环变量
while (j <= 10) // 循环条件，保证遍历到 10
{
if (j % 2 == 0) // 使用取余运算符判断 j 是否为偶数
{
printf("%d\t", j); // 如果是偶数，则打印
}
j++; // 循环变量自增 1，无论是否为偶数都执行
}
printf("\n循环结束后循环变量的值：%d", j); // 此时 j 为 11（超过 10 后退出循环）
return 0;
}上面演示了两种在 C 语言中打印从 0 到 10（包括 0）之间所有偶数的方法。第一种方法通过直接控制循环变量的增量（每次增加 2）来跳过奇数，仅打印偶数。第二种方法则是在循环体内通过条件判断（使用取余运算符 %）来确定当前数字是否为偶数，并据此决定是否打印。两种方法各有特点，第一种方法在处理特定间隔（如偶数）时效率更高，因为它减少了循环迭代次数；而第二种方法则更加灵活，可以很容易地调整为打印奇数或其他基于条件的数字序列。
输出结果如下所示：
1.3.6 案例：计算 100 以内（包括 100）所有数字的和
#include <stdio.h>
int main()
{
// 计算 100 以内（包括 100）所有数字的和
int sum = 0; // 定义一个整型变量 sum，用于累加和，初始化为 0
int i = 1; // 定义一个整型循环变量 i，并初始化为 1，作为累加和的起始数字
// 使用 while 循环遍历 1 到 100（包括 100）的所有整数
while (i <= 100)
{
sum += i; // 将当前数字 i 加到 sum 上，实现累加
i++; // 循环变量 i 自增 1，为下一次循环做准备
}
// 输出计算结果
printf("100以内（包括100）所有数字的和是 %d \n", sum); // 5050
printf("循环结束后循环变量的值：%d", i); // 101
return 0;
}1.3.7 案例：计算 10 以内所有奇数的乘积
#include <stdio.h>
int main()
{
// 计算 10 以内所有奇数的乘积
int product = 1; // 用于记录奇数的乘积，初始化为 1（任何数与 1 相乘都保持不变）
int i = 1; // 从 1 开始，因为 1 是第一个奇数
// 使用 while 循环遍历 10 以内的所有奇数
while (i < 10) // 循环条件是 i 小于 10，确保我们只计算到 9
{
product *= i; // 将当前奇数 i 乘以 product，更新 product 的值
i += 2; // 循环变量 i 每次增加 2，以跳过偶数，直接处理下一个奇数
}
printf("10以内所有奇数的乘积是 %d \n", product); // 945
printf("循环结束后循环变量的值：%d \n", i); // 11（因为当 i 为 9 时，i+=2 会使 i 变为 11，然后循环条件不再满足）
// 另外一种方法
i = 1; // 重置循环变量
product = 1; // 重置变量值
while (i < 10)
{
if (i % 2 != 0) // 基数的判断
{
product *= i;
}
i++;
}
printf("10以内所有奇数的乘积是 %d \n", product); // 945
printf("循环结束后循环变量的值：%d \n", i); // 10
return 0;
}输出结果如下所示：
1.4 不确定循环
不确定循环意味着在循环开始前，无法确切知道循环将会执行多少次，这取决于循环的条件何时变为假（false，0）。
1.4.1 案例：匹配密码
实现需求：输入 6 位数密码，直到密码匹配成功结束循环。
#include <stdio.h>
int main()
{
// 内置密码常量
const int pwd1 = 123456;
// 定义变量用于获取输入的密码
int pwd2 = 0; // 最好初始化一下，防止垃圾值一开始真的就和密码一样
// 使用 while 循环进行密码验证，不相等就一直循环，直到输入的密码与正确密码一致
while (pwd1 != pwd2)
{
printf("请输入6位数字密码：");
scanf("%d", &pwd2); // 读取用户输入的密码
// 检查密码是否正确
// 暂时先不考虑输入的类型，有无等
if (pwd1 != pwd2)
{
printf("密码错误，请重试。\n"); // 密码错误时给出提示
}
}
printf("密码正确，欢迎回家！");
return 0;
}输出结果如下所示：
2 do-while 循环
2.1 基本语法
do
{
循环体语句；
} while (循环条件表达式); // 注意这里有分号;do…while 循环是先执行再判断，但只有第一次循环语句的执行没有经过判断，以后的每一次仍然先经过判断。
注意 while 后面的分号不能省略。
2.2 流程图
2.3 计数循环
在 C 语言中使用 do-while 实现计数循环时同样需要遵循三个基本原则：1. 必须初始化循环变量；2. 循环变量比较作为循环条件；3. 循环变量变化。
2.3.1 案例：循环打印语句
使用 do-while 循环实现：输出10次 "我第n天吃了n个韭菜馅的包子"。
#include <stdio.h>
int main()
{
// 初始化循环变量 i 为 0 ，用于记录天数和包子数量
int i = 0;
// 使用 do-while 循环来重复执行代码块，直到 i 不再小于 10
do
{
printf("我第 %d 天吃了 %d 个韭菜馅的包子 \n", i, i);
// 循环变量 i 自增，为下一次循环做准备
i++;
// do-while 循环的循环条件检查，但条件检查在循环体执行之后进行
} while (i < 10); // 当 i 小于 10 时，循环继续；否则，循环结束
// 循环结束后，打印循环变量的值，此时 i 应该等于 10
// %i 等价于 %d
printf("循环结束后循环变量的值： %i\n", i);
return 0;
}输出结果如下所示：
2.3.2 案例：循环输出数字 7~15
#include <stdio.h>
int main()
{
// 循环输出数字 7 到 15（包括 7 和 15）
int i = 7;
// 使用 do-while 循环来重复执行代码块
do
{
printf("%d \t", i);
i++;
// 如果 i 小于或等于 15，则循环继续；否则，循环结束
} while (i <= 15);
// 循环结束后，打印循环变量的值，此时 i 应该等于 16
printf("\n循环结束后循环变量的值：%d", i);
return 0;
}输出结果如下所示：
2.3.3 案例：倒序输出数字 56 ~ 43
#include <stdio.h>
int main()
{
// 倒序输出数字 56 到 43（包括 56 和 43）
int i = 56;
do
{
printf("%d \t", i);
i--;
} while (i >= 43);
// 循环结束后，打印循环变量的值，此时 i 应该等于 42
printf("\n循环结束后循环变量的值：%d", i);
return 0;
}输出结果如下所示：
2.3.4 案例：输出 10（包括 10）以内所有的偶数
#include <stdio.h>
int main()
{
// 1. 通过控制循环变量来打印偶数（从 0 到 10，包括 0）
int i = 0; // 初始化循环变量
do
{
printf("%d\t", i);
i += 2; // 循环变量自增 2，以跳过奇数，只打印偶数
} while (i <= 10); // 循环条件，保证打印到 10（包括 0）
printf("\n循环结束后循环变量的值：%d \n", i); // 此时 i 为 12（最后一次 10 + 2）
// 2. 通过判断奇偶来打印偶数（从 0 到 10，包括 0）
int j = 0; // 初始化循环变量
do
{
if (j % 2 == 0) // 使用取余运算符判断 j 是否为偶数
{
printf("%d\t", j); // 如果是偶数，则打印
}
j++; // 循环变量自增 1，无论是否为偶数都执行
} while (j <= 10); // 循环条件，保证遍历到 10
printf("\n循环结束后循环变量的值：%d \n", j); // 此时 j 为 11（最后一次 10 + 1）
return 0;
}输出结果如下所示：
2.3.5 案例：计算 100 以内（包括 100）所有数字的和
#include <stdio.h>
int main()
{
// 计算 100 以内（包括 100）所有数字的和
int sum = 0; // 定义一个整型变量 sum，用于累加和，初始化为 0
int i = 1; // 定义一个整型循环变量 i，并初始化为 1，作为累加和的起始数字
// 使用 do-while 循环遍历 1 到 100（包括 100）的所有整数
do
{
sum += i; // 将当前数字 i 加到 sum 上，实现累加
i++; // 循环变量 i 自增 1，为下一次循环做准备
} while (i <= 100); // 条件检查在循环体执行之后进行
// 输出计算结果
printf("100以内（包括100）所有数字的和是 %d \n", sum); // 5050
printf("循环结束后循环变量的值：%d", i); // 101
return 0;
}2.3.6 案例：计算 10 以内所有奇数的乘积
#include <stdio.h>
int main()
{
// 方法 1：直接在 do-while 循环中跳过偶数
int product = 1;
int i = 1;
do
{
product *= i; // 将当前奇数 i 乘以 product
i += 2; // 循环变量 i 每次增加 2，跳过偶数
} while (i < 10); // 当 i 小于 10 时，继续循环
printf("方法1：10以内所有奇数的乘积是 %d \n", product); // 945
printf("方法1循环结束后循环变量的值：%d \n", i); // 11（因为 i 在循环内已经增加到了 11）
// 方法 2：在 do-while 循环内部判断奇数
i = 1; // 重置循环变量
product = 1; // 重置变量值
do
{
if (i % 2 != 0) // 判断 i 是否为奇数
{
product *= i; // 若是奇数，则乘以 product
}
i++; // 无论 i 是否为奇数，都递增 i
} while (i < 10); // 当 i 小于等于 10 时，继续循环
printf("方法2：10以内所有奇数的乘积是 %d \n", product); // 945
printf("方法2循环结束后循环变量的值：%d \n", i); // 10
return 0;
}输出结果如下所示：
2.4 不确定循环
不确定循环意味着在循环开始前，无法确切知道循环将会执行多少次，这取决于循环的条件何时变为假（false，0）。
2.4.1 案例：匹配密码
实现需求：输入 6 位数密码，直到密码匹配成功结束循环。
#include <stdio.h>
int main()
{
// 内置密码常量
const int pwd1 = 123456;
// 定义变量用于获取输入的密码
int pwd2 = 0; // 初始化以防止可能的垃圾值问题（就怕一开始垃圾值就是正确密码）
// 使用 do-while 循环进行密码验证，至少执行一次，直到输入的密码与正确密码一致
do
{
printf("请输入6位数字密码：");
scanf("%d", &pwd2); // 读取用户输入的密码
// 检查密码是否正确
if (pwd1 != pwd2)
{
printf("密码错误，请重试。\n"); // 密码错误时给出提示
}
} while (pwd1 != pwd2); // 如果密码不匹配，则继续循环
printf("密码正确，欢迎回家！");
return 0;
}输出结果如下所示：
3 while 和 do while 的差异
3.1 语法结构差异
while 循环：其语法结构为 while (条件) {循环体语句}。它首先判断条件是否为真，如果为真，则执行循环体内的语句；然后再次判断条件，如此循环，直到条件为假时退出循环。
do-while 循环：其语法结构为 do {循环体语句} while (条件);。它首先执行一次循环体内的语句，然后判断条件是否为真，如果为真，则继续执行循环体内的语句，如此循环，直到条件为假时退出循环。
3.2 执行次数差异
while 循环：在循环开始前就进行条件判断，如果条件一开始就不满足（即为假），则循环体内的语句一次也不会执行。
do-while 循环：无论条件是否满足，都会至少执行一次循环体内的语句。这是因为条件判断是在执行完第一次循环体内的语句之后进行的。
3.3 适用场景差异
while 循环：适用于那些需要在条件满足时执行一段代码块的场景。如果一开始条件就不满足，则不会执行任何操作。
do-while 循环：适用于那些至少需要执行一次操作，然后再根据条件判断是否继续执行的场景。例如，读取用户输入或者进行一些必要的初始化操作。
3.4 注意事项
在选择使用 while 还是 do-while 循环时，应根据具体需求和场景来决定，以便更好地控制程序的流程。
在使用 do-while 循环时，需要特别注意循环条件，以避免因条件始终为真而导致的无限循环，如下代码所示：
#include <stdio.h>
int main()
{
// while 循环 一次也不会执行
// 因为在循环开始前，n 的值已经是 10，而循环条件是 n > 10，这从一开始就不满足
// 所以循环体内的代码一次也不会执行
int n = 10;
while (n > 10)
{
printf("%d \n", n); // 这行代码不会被执行
n++; // 同样，这行代码也不会被执行
}
// 下面这个 do-while 会造成死循环
n = 10;
do
{
printf("%d \n", n); // 这行代码会执行一次，打印出 10
n++; // 然后 n 变成 11
} while (n > 10); // 由于现在 n 恒大于 10，会一直循环打印，ctrl + c 可以停止程序
return 0;
}4 for 循环
4.1 基本语法
for (循环变量初始化; 循环条件表达式; 循环变量变化) // 分号分隔
{
循环语句;
}循环变量初化只执行一次，且循环开始前就执行。
循环条件表达式在每次循环迭代之前，都会评估这个条件表达式，如果条件为真（即，表达式的结果是非零值），则执行循环体；如果条件为假（即，表达式的结果是零），则退出循环，继续执行 for 循环之后的代码。
循环变量变化在每次循环迭代结束时，都会执行这个表达式。它通常用于更新或递增循环控制变量，为下一次迭代做准备。执行完后，程序会再次回到循环条件表达式进行评估。如果条件仍然为真，则重复执行上述步骤；如果条件为假，不会在执行它了，直接退出循环。
4.2 流程图
4.3 执行顺序
for 循环的执行顺序可以分为以下几个步骤：
for (初始化表达式; 条件表达式; 更新表达式) {
// 循环体
// 这里是要重复执行的代码
}- 初始化（Initialization）:
- 首先执行初始化表达式（通常用于设置循环控制变量）。这部分只执行一次，在循环开始之前执行。
- 条件检查（Condition Checking）:
- 接下来，程序会检查条件表达式的真假。如果条件为真（非零值），则执行循环体；如果条件为假（零值），则循环结束，程序跳过循环体并继续执行循环之后的代码。
- 循环体执行（Body Execution）:
- 如果条件为真，则执行循环体内的代码。这可能包括任何需要重复执行的语句或代码块。
- 更新表达式（Update Expression）:
- 每次完成一次循环体的执行后，都会执行更新表达式。这通常用于修改循环控制变量。
- 重复步骤 2-4:
- 在执行完更新表达式后，再次回到条件检查阶段，重复上述过程直到条件变为假。
当条件表达式不再为真时，循环终止，程序将从紧跟在 for 循环后的下一条语句继续执行。
4.4 计数循环
在 C 语言中使用 for 实现计数循环时同样需要遵循三个基本原则：1. 必须初始化循环变量；2. 循环变量比较作为循环条件；3. 循环变量变化。
#include <stdio.h>
int main()
{
// for 循环
for (int i = 0; i < 10; i++)
{
printf("i = %d \t", i); // i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9
}
printf("\n\n");
// 对应 while 循环的与法
int i = 0;
while (i < 10)
{
printf("i = %d \t", i); // i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 i = 6 i = 7 i = 8 i = 9
i++;
}
return 0;
}
4.4.1 案例：循环打印语句
使用 for 循环实现：输出10次 "我第n天吃了n个韭菜馅的包子"。
#include <stdio.h>
int main()
{
// 使用 for 循环来重复执行一段代码 10 次
// 初始化 i 为 0，当 i 小于 10 时执行循环体，每次循环结束 i 的值增加 1
for (int i = 0; i < 10; i++)
{
printf("我第%d天吃了%d个韭菜馅的包子 \n", i, i);
}
return 0;
}输出结果如下所示：
4.4.2 案例：循环输出数字 7~15
#include <stdio.h>
int main()
{
// 使用 for 循环来遍历数字 7 到 15（包括 7 和 15）
// 初始化循环变量 i 为 7，循环条件为 i 小于或等于 15，每次循环后 i 自增 1
for (int i = 7; i <= 15; i++)
{
// %d 是一个占位符，用于表示一个整数，它会被变量 i 的值替换
printf("%d \t", i);
// 输出：7 8 9 10 11 12 13 14 15
}
return 0;
}4.4.3 案例：倒序输出数字 56 ~ 43
#include <stdio.h>
int main()
{
// 倒叙输出数字 56 ~ 43
for (int i = 56; i >= 43; i--)
{
printf("%d \t", i);
// 输出：56 55 54 53 52 51 50 49 48 47 46 45 44 43
}
return 0;
}4.4.4 案例：输出 10（包括 10）以内所有的偶数
#include <stdio.h>
int main()
{
// 1. 通过控制循环变量来打印偶数（从 0 到 10，包括 0）
int i;
// 初始化 i 为 0，循环条件为 i <= 10，每次循环 i 自增 2
for (i = 0; i <= 10; i += 2)
{
printf("%d\t", i);
}
printf("\n循环结束后循环变量的值（如果需要知道）：%d \n", i);
// 2. 通过判断奇偶来打印偶数（从 0 到 10，包括 0）
int j = 0;
// 初始化在外面做了，括号里面可以省略
// 循环条件为 j <= 10，每次循环 j 自增 1
for (; j <= 10; j++)
{
if (j % 2 == 0) // 使用取余运算符判断 j 是否为偶数
{
printf("%d\t", j);
}
}
printf("\n循环结束后循环变量的值：%d\n", j);
return 0;
}输出结果如下所示：
4.4.5 案例：计算 100 以内（包括 100）所有数字的和
#include <stdio.h>
int main()
{
// 计算 100 以内（包括 100）所有数字的和
// 定义变量记录和
int sum = 0; // 要在循环外面定义，不然再for循环外面无法访问
for (int i = 1; i <= 100; i++)
{
sum += i;
}
printf("100以内（包括100）所有数字的和是 %d \n", sum); // 5050
return 0;
}4.4.6 案例：计算 10 以内所有奇数的乘积
#include <stdio.h>
int main()
{
// 方法 1：直接在 for 循环中处理奇数
int product = 1; // 初始化乘积变量
int i = 1; // 初始化循环变量
// 从 1 开始，每次增加 2，直到 10
for (; i <= 10; i += 2)
{
product *= i; // 将当前奇数 i 乘以 product
}
printf("方法1：10以内所有奇数的乘积是 %d \n", product); // 945
printf("方法1循环结束后循环变量的值：%d \n", i); // 11
// 方法 2：在 for 循环内部判断奇数
product = 1; // 重置乘积变量
int j = 1; // 初始化循环变量
// 从 1 开始，每次增加 1，直到 10
for (; j <= 10; j++)
{
if (j % 2 != 0) // 判断 j 是否为奇数
{
product *= j; // 若是奇数，则乘以 product
}
}
printf("方法2：10以内所有奇数的乘积是 %d \n", product); // 945
printf("方法2循环结束后循环变量的值：%d \n", j); // 11
return 0;
}4.5 不确定性循环
不确定循环意味着在循环开始前，无法确切知道循环将会执行多少次，这取决于循环的条件何时变为假（false，0）。
4.5.1 案例：匹配密码
实现需求：输入 6 位数密码，直到密码匹配成功结束循环。
#include <stdio.h>
int main()
{
// 定义一个常量，作为正确的密码（这里为了示例简单，设为 123456）
const int pwd1 = 123456;
// 定义一个变量，用于存储用户输入的密码
int pwd2 = 0; // 初始化以防止可能的垃圾值问题（就怕一开始垃圾值就是正确密码）
// 使用 for 循环来不断要求用户输入密码，直到输入的密码与正确的密码匹配
// 注意：for 循环的初始化部分和迭代部分都是空的，因为我们会在循环体内手动处理
for (; pwd1 != pwd2;) // 循环条件：当 pwd1 不等于 pwd2 时，继续循环
{
printf("请输入6位数密码：");
scanf("%d", &pwd2);
// 检查密码是否正确
if (pwd1 != pwd2) // 如果输入的密码不正确
{
// 密码错误时给出提示
printf("密码错误，请重试。\n");
}
// 如果密码正确，则不需要任何操作，因为循环条件（pwd1 != pwd2）将不再成立，循环会自动结束
}
// 当循环结束时，说明用户已经输入了正确的密码
printf("密码正确，欢迎回家！");
return 0;
}4.6 特殊结构的 for 循环
在 C 语言中，for 循环的灵活性和多样性体现在其能够支持多种简写或变体结构，这些结构在编程实践中非常有用。首先，标准的 for 循环结构包括初始化表达式、条件表达式和迭代表达式，这三者均写在循环控制语句的圆括号内。然而，在某些情况下，我们可以通过省略这些表达式的一部分或全部，来形成 for 循环的特殊结构。
省略初始化表达式：当循环变量已在循环外部初始化时，可以省略 for 循环中的初始化部分。例如，在下面代码中的第 2 个 for 循环示例展示了如何在循环外部初始化变量 i，并在 for 循环中仅保留条件表达式和迭代表达式。这种结构在需要在循环外部进行复杂初始化时特别有用。
省略迭代表达式：在某些情况下，迭代逻辑可能较为复杂，不适合放在 for 循环的迭代表达式部分。此时，可以将迭代逻辑放在循环体内部的大括号中。如下面代码中的第 3 个 for 循环示例所示，迭代变量 i 的增加操作被放在了循环体内部，这种结构提供了更大的灵活性来处理复杂的迭代逻辑。
无限循环：当 for 循环的圆括号内为空时，将形成一个无限循环。如下面代码中的第 4 个 for 循环。这通常用于需要等待某个条件成立才能退出的场景，但必须在循环体内有明确的退出条件（如 break 语句）以避免程序挂起。如下面代码中的第 5 个 for 循环。然而，需要注意的是，无限循环应该谨慎使用，并确保在适当的时候能够退出。
使用多个初始化变量：for 循环的初始化表达式不仅可以用于初始化一个变量，还可以同时初始化多个变量。用分号 ; 分隔出 3 个部分，每个部分中使用逗号 , 分隔各个内容，或使用逻辑连接符。如下面代码中的第 6 个 for 循环示例中，我们同时初始化了两个变量 x 和 y，并在循环条件中同时检查了这两个变量的值。这种结构在处理需要同时迭代的多个变量时非常有用。这种情况下，只要有一个判断条件不满足就结束循环。
#include <stdio.h>
int main()
{
// 1. 标准结构
// 初始化 i 为 1，当 i 小于 10 时循环，每次循环 i 增加 2
for (int i = 1; i < 10; i += 2)
{
printf("%d ", i); // 1 3 5 7 9
}
printf("\n\n");
// 2. 循环变量初始化写在外面
int i = 1; // 重新初始化 i
// 省略初始化部分，仅保留循环条件和更新表达式
for (; i < 10; i += 2)
{
printf("%d ", i); // 1 3 5 7 9
}
printf("\n\n");
// 3.循环变量初始化写在外面,循环变量的更新写在大括号中
i = 1; // 重新初始化 i
// 省略初始化部分和循环变量更新
for (; i < 10;)
{
printf("%d ", i); // 1 3 5 7 9
i += 2; // 在循环体内更新 i 的值
}
printf("\n\n");
// 4. 所有内容都省略
// for 括号中什么都不写,{}里面也没有明确的退出条件 ——> 死循环
for (;;)
{
printf("死循环 \n"); // 无限次打印“死循环”
// 注意：在实际应用中，应避免编写无限循环，除非有明确的退出条件（如 break 语句）
}
// 5. for()所有内容都省略
// 但循环体内有明确的退出条件 - break
i = 1; // 重新初始化 i
for (;;)
{
if (i >= 10)
{
break;
}
printf("%d ", i); // 1 3 5 7 9
i += 2; // 在循环体内更新 i 的值
}
printf("\n\n");
// 6. 使用两个循环标记变量
// 同时初始化 x 和 y，并设置循环条件
for (int x = 1, y = 10; x < 6, y > 7; x++, y--) // 等价于 &&
{
printf("%d %d \n", x, y);
}
printf("\n\n");
for (int x = 1, y = 10; x < 6 && y > 7; x++, y--)
{
printf("%d %d \n", x, y);
}
printf("\n\n");
for (int x = 1, y = 10; x < 6 || y > 7; x++, y--)
{
printf("%d %d \n", x, y);
}
printf("\n\n");
return 0;
}
注释掉上面代码中的死循环代码块，输出结果如下所示：
5 多重嵌套循环
5.1 介绍
将一个循环放在另一个循环体内，就形成了嵌套循环， 其中，for、while、do…while 均可以作为外层循环和内层循环，建议一般使用两层，最多不要超过 3 层，如果嵌套循环过多，会造成可读性降低。
如果外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。
#include <stdio.h>
int main()
{
int i, j;
int counter = 0; // 计数器，用于跟踪循环的总迭代次数
// 外部循环
for (i = 1; i <= 5; i++)
{
// 内部循环
for (j = 1; j <= 4; j++)
{
// 这里可以放置你想要在每次迭代中执行的代码
// 例如，我们可以简单地打印当前的(i, j)值
printf("(%d, %d) ", i, j);
// 更新计数器
counter++;
}
// 内部循环结束后，打印一个换行符以分隔不同的外部循环迭代
printf("\n");
}
// 循环结束后，打印总的迭代次数
printf("Total iterations: %d\n", counter); // 20
return 0;
}输出结果如下所示：
5.2 案例演示
5.2.1 打印二维坐标
#include <stdio.h>
int main()
{
// 输入列数和行数
int rows, cols;
printf("请输入行数："); // 提示用户输入行数
scanf("%d", &rows); // 读取用户输入的行数到变量 rows 中
printf("请输入列数："); // 提示用户输入列数
scanf("%d", &cols); // 读取用户输入的列数到变量 cols 中
// 使用嵌套循环打印二维坐标
for (int i = 0; i < rows; i++) // 外层循环控制行数
{
for (int j = 0; j < cols; j++) // 内层循环控制列数
{
printf("[%d,%d] ", i, j); // 打印当前位置的坐标，坐标格式为[行,列]
}
printf("\n"); // 每打印完一行后换行
}
return 0;
}输出结果如下所示：
5.2.2 打印出九九乘法表形式1
要求输出如下形式的九九乘法表：
题目分析：主要是搞清楚行和列的关系，从图中可以看出第一行只有一列，第二行只有两列……第九行只有九列，即是说列的数量要小于等于行的数量。即内层循环变量 j（相当于列） 要小于等于外层循环变量 i （相当于行）。
代码如下：
#include <stdio.h>
int main()
{
// 外层循环控制乘法表的行数，从 1 到 9
for (int i = 1; i <= 9; i++)
{
// 内层循环控制每行中乘法表达式的数量，并且与外层循环的变量 i 相等，
// 以便实现乘法表的形状（左下对齐的直角三角形）
for (int j = 1; j <= i; j++)
{
// 打印乘法表达式，格式为 "j*i=结果"，其中 j 和 i 是乘法中的两个数，
// 结果是它们的乘积，\t是制表符，用于在表达式之间添加水平间距
printf("%d*%d=%d\t", j, i, i * j);
}
// 每完成一行的打印后，输出一个换行符，以便开始打印下一行
printf("\n");
}
return 0;
}5.2.3 打印出九九乘法表形式2
要求输出如下形式的九九乘法表：
题目分析：方法一：相比较第一种形式的九九乘法表，可以看出对称关系，即相当于把第一行变到了第九行，第二行变到了第八行……第九行变到了第一行，所以只需要将原来行号的变化进行修改，即把外层循环变量 i 的变化从 1 到 9 改成 9 到 1 。 方法二：可以看出第一行一共有九列，第二行一共有八列……第九行一共有一列，所以可以得到这样的关系：行号变化为 1 到 9 时，列的数量为 9 到 1，当行号为 i ，列好为 j 时，即有 j <= (10-i)。
代码如下：
#include <stdio.h>
int main()
{
// 方法1
// 外层循环，从 9 递减到 1，控制乘法表的行数
for (int i = 9; i >= 1; i--)
{
// 内层循环，从 1 递增到 i，控制每行中乘法表达式的数量
// 由于外层循环是递减的，所以这里会打印出一个左上对角直角三角形
for (int j = 1; j <= i; j++)
{
printf("%d*%d=%d\t", j, i, i * j);
}
printf("\n");
}
// 方法2
// 外层循环，从 1 增加到 9，控制乘法表的行数
for (int i = 1; i <= 9; i++)
{
// 内层循环，从 1 递增到 10-i，控制每行中乘法表达式的数量
// 由于外层循环是递减的，所以这里会打印出一个左上对角直角三角形
for (int j = 1; j <= 10 - i; j++)
{
printf("%d*%d=%d\t", j, (10 - i), (10 - i) * j);
}
printf("\n");
}
return 0;
}5.2.4 打印出九九乘法表形式3
要求输出如下形式的九九乘法表：
题目分析：相比第一种形式的九九乘法表，相当于部分行的前面多了一些空格。所以需要先来一个循环进行空位的输出。第一行前面有八个制表位，第二行前面有七个制表位……第九行前面有零个制表位，所以若用 i 表示行号，变化为 1 到 9 时，那么制表位的变化就是从 8 到 0，相应的变化为 9-i 。
代码如下：
#include <stdio.h>
int main()
{
// 外层循环控制乘法表的行数，从 1 到 9
for (int i = 1; i <= 9; i++)
{
// 内层循环 1：打印前导空格（制表位实现），以实现乘法表的右对齐
// 空格数量随着 i（行数） 的增加而减少，即 9-i 个空格（制表位）
for (int j = 1; j <= 9 - i; j++)
{
printf("\t"); // 打印一个制表符作为空格
}
// 内层循环 2：打印乘法表达式
// 对于每一行，打印从1到i的乘法表达式
for (int j = 1; j <= i; j++)
{
// 打印乘法表达式，格式为 "j*i=乘积"，\t 用于分隔表达式
printf("%d*%d=%d\t", j, i, i * j);
}
printf("\n");
}
return 0;
}5.2.5 打印出九九乘法表形式4
要求输出如下形式的九九乘法表：
题目分析：相比第二种形式的九九乘法表，相当于部分行的前面多了一些空格。所以需要先来一个循环进行空位的输出。第一行前面有零个制表位，第二行前面有一个制表位……第九行前面有八个制表位，所以若用 i 表示行号，变化为 9 到 1 时，那么制表位的变化就是从 0 到 8，相应的变化为 9-i 。
代码如下：
#include <stdio.h>
int main()
{
// 外层循环，从 9 递减到 1，控制乘法表的行数
for (int i = 9; i >= 1; i--)
{
// 内层循环 1，打印每行乘法表达式前的空格（这里使用制表符 \t 代替空格以更好地对齐）
// 9 - i 计算出每行前面需要打印的制表符数量，以形成倒立的三角形效果
for (int j = 1; j <= 9 - i; j++)
{
printf("\t"); // 打印一个制表符
}
// 内层循环 2，打印乘法表达式
// j 从 1 循环到 i，与当前行数 i 相对应，打印出从 1*i 到 i*i 的乘法表达式
for (int j = 1; j <= i; j++)
{
printf("%d*%d=%d\t", j, i, i * j); // 打印乘法表达式，并用制表符分隔
}
printf("\n");
}
return 0;
}6 死循环
在 C 语言中，死循环是指一个循环结构在执行过程中，由于循环条件永远为真（或者循环体中没有修改循环条件使其变为假的操作），导致循环体不断重复执行，从而无法自然终止的循环。
死循环在某些情况下是有用的，比如在需要程序持续运行直到外部干预（如用户输入、信号中断等）时。但是，如果死循环的使用不当，可能会导致程序无法正常结束，浪费系统资源，甚至造成程序崩溃。
C 语言中常用的死循环有两种形式：while 循环和 for 循环。
6.1 使用 while 循环实现死循环
while (1) {
// 循环体
// 这里可以放置需要持续执行的代码
}在这个例子中，循环条件被设置为 1，这是一个永远为真的表达式，因此循环体会不断重复执行。
6.2 使用 for 循环实现死循环
for (;;) {
// 循环体
// 这里可以放置需要持续执行的代码
}for 循环的初始化表达式、条件表达式和迭代表达式都可以省略。当条件表达式省略时，它被视为永远为真，因此循环体会不断重复执行。
提示：再 VS Code 中可以使用快捷键 Ctrl + C 退出死循环！
6.3 注意事项
虽然死循环在某些情况下是有用的，但应该谨慎使用，并确保有明确的退出机制（如通过检测特定条件、捕获信号、显示的 break 等）。
在使用死循环时，应该在循环体内适当位置添加延时或空操作（如 sleep 函数、usleep 函数或简单的空语句;），以避免过度占用 CPU 资源。
如果死循环的目的是等待某个事件或条件发生，那么更推荐使用条件变量、信号量等同步机制，而不是简单的忙等待（即无延时的死循环）。
6.4 示例：使用死循环等待用户输入
虽然这不是死循环的最佳用途（因为更好的做法是使用阻塞读取函数等待用户输入），但以下示例展示了如何在死循环中等待用户输入。
#include <stdio.h>
int main()
{
int input; // 用于存储用户输入的整数
printf("请输入一个整数（输入0以退出）：");
// 使用死循环等待用户输入
while (1)
{
scanf("%d", &input); // 读取用户输入的整数
// 检查用户是否输入了 0
if (input == 0)
{
printf("退出程序。\n");
break; // 退出循环
}
// 如果不是 0，则打印输入的整数
printf("你输入了：%d\n", input);
printf("请继续输入一个整数（输入0以退出）：");
}
return 0;
}在这个示例中，我们定义了一个 int 类型的变量 input 来存储用户输入的整数。然后，我们使用了一个 while(1) 死循环来不断等待用户输入。在循环体内，我们使用 scanf 函数读取用户输入的整数，并将其存储在 input 变量中。接着，我们检查 input 的值是否为 0。如果是，则打印一条消息并使用 break 语句退出循环。如果 input 的值不是 0，则打印用户输入的整数，并继续下一次循环，等待用户的新输入。
请注意，这个示例使用了 scanf 函数来读取用户输入的整数。scanf 是一个阻塞读取函数，意味着它会等待用户输入，直到用户输入了一些东西并按下了回车键。然而，由于我们将它放在了一个死循环中，所以程序会不断地重复这个过程，直到用户输入了 0 并按下了回车键为止。
输出结果如下所示：
7 测试题
1. 请写出下面程序的运行结果：
int i;
for (i = 0; i < 5; i++)
{
printf("%d ", i);
i++;
}
printf("\n%d", i);【答案】
0 2 4
6
【解析】
（1）在这个程序中，使用了一个 for 循环来迭代 i 的值，然后在循环体内打印 i 的值，接着将 i 递增，同时，在循环体内部手动将 i 再次递增了一次。
（2）在 for 循环内部，i 从 0 开始，每次递增 2（i++ 和循环自身的 i++）。因此，for 循环将执行 3 次（i=0, 2, 4），分别打印 0，2 和 4。
（3）在循环外部，printf("\n%d", i); 语句将打印循环结束后的i的值，i 最终的值为 6。
2. 以下代码共输出多少次“我爱编程”。
for (int i = 1; i <= 3; i++)
{
for (int j = 1; j <= i; j++)
{
printf("我爱编程");
}
}【答案】6次
【解析】
（1）当 i 等于 1 时，内层循环执行 1 次，输出 "我爱编程" 1 次。
（2）当 i 等于 2 时，内层循环执行 2 次，输出 "我爱编程" 2 次。
（3）当 i 等于 3 时，内层循环执行 3 次，输出 "我爱编程" 3 次。
（4）因此，总共输出了1 + 2 + 3 = 6 次 "我爱编程"。
3. 使用 while 或 for 循环实现一个死循环。
while (1) {
// 循环体
// 这里可以放置需要持续执行的代码
}for (;;) {
// 循环体
// 这里可以放置需要持续执行的代码
}
974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
