目录
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 (;;) {
// 循环体
// 这里可以放置需要持续执行的代码
}