12 程序控制语句:循环控制(while、do-while、for、多重嵌套循环、死循环)

目录

1 while 循环      

1.1 基本语法

1.2 流程图

1.3 计数循环

1.3.1 实现原则

1.3.2 案例:循环输出语句

1.3.3 案例:循环输出数字 7~15

1.3.4 案例:倒序输出数字 56 ~ 43

1.3.5 案例:输出 10(包括 10)以内所有的偶数

1.3.6 案例:计算 100 以内(包括 100)所有数字的和

1.3.7 案例:计算 10 以内所有奇数的乘积

1.4 不确定循环

1.4.1 案例:匹配密码

2 do-while 循环

2.1 基本语法

2.2 流程图

2.3 计数循环

2.3.1 案例:循环打印语句

2.3.2 案例:循环输出数字 7~15

2.3.3 案例:倒序输出数字 56 ~ 43

2.3.4 案例:输出 10(包括 10)以内所有的偶数

2.3.5 案例:计算 100 以内(包括 100)所有数字的和

2.3.6 案例:计算 10 以内所有奇数的乘积

2.4 不确定循环

2.4.1 案例:匹配密码

3 while 和 do while 的差异

3.1 语法结构差异

3.2 执行次数差异

3.3 适用场景差异

3.4 注意事项

4 for 循环

4.1 基本语法

4.2 流程图

4.3 执行顺序

4.4 计数循环

4.4.1 案例:循环打印语句

4.4.2 案例:循环输出数字 7~15

4.4.3 案例:倒序输出数字 56 ~ 43

4.4.4 案例:输出 10(包括 10)以内所有的偶数

4.4.5 案例:计算 100 以内(包括 100)所有数字的和

4.4.6 案例:计算 10 以内所有奇数的乘积

4.5 不确定性循环

4.5.1 案例:匹配密码

4.6 特殊结构的 for 循环

5 多重嵌套循环

5.1 介绍

5.2 案例演示

5.2.1 打印二维坐标

5.2.2 打印出九九乘法表形式1

5.2.3 打印出九九乘法表形式2

5.2.4 打印出九九乘法表形式3

5.2.5 打印出九九乘法表形式4

6 死循环

6.1 使用 while 循环实现死循环

6.2 使用 for 循环实现死循环

6.3 注意事项

6.4 示例:使用死循环等待用户输入

7 测试题


        在 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 的值将是 10printf("循环结束后循环变量的值:%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,用于累加和,初始化为 0int i = 1;   // 定义一个整型循环变量 i,并初始化为 1,作为累加和的起始数字// 使用 while 循环遍历 1 到 100(包括 100)的所有整数while (i <= 100){sum += i; // 将当前数字 i 加到 sum 上,实现累加i++;      // 循环变量 i 自增 1,为下一次循环做准备}// 输出计算结果printf("100以内(包括100)所有数字的和是 %d \n", sum); // 5050printf("循环结束后循环变量的值:%d", i);              //  101return 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); // 945printf("循环结束后循环变量的值:%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); // 945printf("循环结束后循环变量的值:%d \n", i);      //  10return 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 不再小于 10do{printf("我第 %d 天吃了 %d 个韭菜馅的包子 \n", i, i);// 循环变量 i 自增,为下一次循环做准备i++;// do-while 循环的循环条件检查,但条件检查在循环体执行之后进行} while (i < 10); // 当 i 小于 10 时,循环继续;否则,循环结束// 循环结束后,打印循环变量的值,此时 i 应该等于 10// %i 等价于 %dprintf("循环结束后循环变量的值: %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 应该等于 16printf("\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 应该等于 42printf("\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); // 循环条件,保证遍历到 10printf("\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,用于累加和,初始化为 0int 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); // 5050printf("循环结束后循环变量的值:%d", i);               //  101return 0;
}

2.3.6 案例:计算 10 以内所有奇数的乘积

#include <stdio.h>int main()
{// 方法 1:直接在 do-while 循环中跳过偶数int product = 1;int i = 1;do{product *= i; // 将当前奇数 i 乘以 producti += 2;       // 循环变量 i 每次增加 2,跳过偶数} while (i < 10); // 当 i 小于 10 时,继续循环printf("方法1:10以内所有奇数的乘积是 %d \n", product); // 945printf("方法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); // 945printf("方法2循环结束后循环变量的值:%d \n", i);        // 10return 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); // 这行代码会执行一次,打印出 10n++;                // 然后 n 变成 11} while (n > 10); // 由于现在 n 恒大于 10,会一直循环打印,ctrl + c 可以停止程序return 0;
}

4 for 循环

4.1 基本语法

for (循环变量初始化; 循环条件表达式; 循环变量变化) // 分号分隔
{循环语句;
}

        循环变量初化只执行一次,且循环开始前就执行

        循环条件表达式在每次循环迭代之前,都会评估这个条件表达式,如果条件为真(即,表达式的结果是非零值),则执行循环体;如果条件为假(即,表达式的结果是零),则退出循环,继续执行 for 循环之后的代码。

        循环变量变化在每次循环迭代结束时,都会执行这个表达式。它通常用于更新或递增循环控制变量,为下一次迭代做准备。执行完后,程序会再次回到循环条件表达式进行评估。如果条件仍然为真,则重复执行上述步骤;如果条件为假,不会在执行它了,直接退出循环。

4.2 流程图

4.3 执行顺序

        for 循环的执行顺序可以分为以下几个步骤:

for (初始化表达式; 条件表达式; 更新表达式) {// 循环体// 这里是要重复执行的代码
}
  1. 初始化(Initialization):
    1. 首先执行初始化表达式(通常用于设置循环控制变量)。这部分只执行一次,在循环开始之前执行
  2. 条件检查(Condition Checking):
    1. 接下来,程序会检查条件表达式的真假。如果条件为真(非零值),则执行循环体;如果条件为假(零值),则循环结束,程序跳过循环体并继续执行循环之后的代码。
  3. 循环体执行(Body Execution):
    1. 如果条件为真,则执行循环体内的代码。这可能包括任何需要重复执行的语句或代码块。
  4. 更新表达式(Update Expression):
    1. 每次完成一次循环体的执行后,都会执行更新表达式。这通常用于修改循环控制变量。
  5. 重复步骤 2-4:
    1. 在执行完更新表达式后,再次回到条件检查阶段,重复上述过程直到条件变为假。

        当条件表达式不再为真时,循环终止,程序将从紧跟在 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 = 9i++;}return 0;
}

4.4.1 案例:循环打印语句

        使用 for 循环实现:输出10次 "我第n天吃了n个韭菜馅的包子"。

#include <stdio.h>int main()
{// 使用 for 循环来重复执行一段代码 10 次// 初始化 i 为 0,当 i 小于 10 时执行循环体,每次循环结束 i 的值增加 1for (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 自增 1for (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 ~ 43for (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 自增 2for (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 自增 1for (; 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); // 5050return 0;
}

4.4.6 案例:计算 10 以内所有奇数的乘积

#include <stdio.h>int main()
{// 方法 1:直接在 for 循环中处理奇数int product = 1; // 初始化乘积变量int i = 1; // 初始化循环变量// 从 1 开始,每次增加 2,直到 10for (; i <= 10; i += 2){product *= i; // 将当前奇数 i 乘以 product}printf("方法1:10以内所有奇数的乘积是 %d \n", product); // 945printf("方法1循环结束后循环变量的值:%d \n", i);        // 11// 方法 2:在 for 循环内部判断奇数product = 1; // 重置乘积变量int j = 1; // 初始化循环变量// 从 1 开始,每次增加 1,直到 10for (; j <= 10; j++){if (j % 2 != 0) // 判断 j 是否为奇数{product *= j; // 若是奇数,则乘以 product}}printf("方法2:10以内所有奇数的乘积是 %d \n", product); // 945printf("方法2循环结束后循环变量的值:%d \n", j);        // 11return 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 增加 2for (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 9i += 2;           // 在循环体内更新 i 的值}printf("\n\n");// 4. 所有内容都省略// for 括号中什么都不写,{}里面也没有明确的退出条件 ——> 死循环for (;;){printf("死循环 \n"); // 无限次打印“死循环”// 注意:在实际应用中,应避免编写无限循环,除非有明确的退出条件(如 break 语句)}// 5. for()所有内容都省略// 但循环体内有明确的退出条件 - breaki = 1; // 重新初始化 ifor (;;){if (i >= 10){break;}printf("%d ", i); // 1 3 5 7 9i += 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);  // 20return 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 到 9for (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 到 9for (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); // 读取用户输入的整数// 检查用户是否输入了 0if (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 (;;) {  // 循环体  // 这里可以放置需要持续执行的代码  
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/405830.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

使用 Go 语言将 Base64 编码转换为 PDF 文件

使用Go语言将PDF文件转换为Base64编码-CSDN博客文章浏览阅读104次&#xff0c;点赞2次&#xff0c;收藏5次。本文介绍了如何使用 Go 语言将 PDF 文件转换为 Base64 编码&#xff0c;并保存到文件中。https://blog.csdn.net/qq_45519030/article/details/141224319 在现代编程中…

【WebSocket】websocket学习【二】

1.需求&#xff1a;通过websocket实现在线聊天室 2.流程分析 3.消息格式 客户端 --> 服务端 {"toName":"张三","message":"你好"}服务端 --> 客户端 系统消息格式&#xff1a;{"system":true,"fromName"…

SQL注入(head、报错、盲注)

目录 【学习目标、重难点知识】 【学习目标】 【重难点知识】 1. 报错注入 1.1 那么什么是报错注入呢&#xff1f; 1.2 报错注入原理 extractvalue函数 updatexml函数 1.3 靶场解析 靶场练习 2. HEAD注入 2.1 相关全局变量 2.2 靶场解析 burp暴力破解 靶场练习 3…

Spring核心思想讲解之控制反转(IOC)

控制反转概述 控制反转实现方式 XML方式 方式一 方式二 方式三 注解方式 第一步 第二步 第三步 依赖注入&#xff08;DI&#xff09;实现方式 XML方式 手动注入 set注入 构造器注入 自动注入 set注入 构造方法注入 注解方式 方式一&#xff1a; 方式二&…

Transformer模型中的Position Embedding实现

引言 在自然语言处理&#xff08;NLP&#xff09;中&#xff0c;Transformer模型自2017年提出以来&#xff0c;已成为许多任务的基础架构&#xff0c;包括机器翻译、文本摘要和问答系统等。Transformer模型的核心之一是其处理序列数据的能力&#xff0c;而Position Embedding在…

python之matplotlib (1 介绍及基本用法)

介绍 matplotlib是Python中的一个绘图库&#xff0c;它提供了一个类似于 MATLAB 的绘图系统。使用matplotlib你可以生成图表、直方图、功率谱、条形图、错误图、散点图等。matplotlib广泛用于数据可视化领域&#xff0c;是 Python 中最著名的绘图库之一。 同样matplotlib的安…

Java数组怎么转List,Stream的基本方法使用教程

Stream流 Java 的 Stream 流操作是一种简洁而强大的处理集合数据的方式,允许对数据进行高效的操作,如过滤、映射、排序和聚合。Stream API 于 Java 8 引入,极大地简化了对集合(如 List、Set)等数据的处理。 一、创建 Stream 从集合创建: List<String> list = Ar…

NGINX 之 location 匹配优先级

章节 1 NGINX 的源码安装 2 NGINX 核心配置详解 3 NGINX 之 location 匹配优先级 4 NGINX 基础参数与功能 目录 1 location 基础语法 1.1 location 语法说明表 1.2 URI部分简单介绍 2 location 匹配优先级 2.1 URI匹配的规则与顺序 2.2 精确匹配(location /1.txt) 2.3 区…

Python个人收入影响因素模型构建:回归、决策树、梯度提升、岭回归

全文链接&#xff1a;https://tecdat.cn/?p37423 原文出处&#xff1a;拓端数据部落公众号 “你的命运早在出生那一刻起便被决定了。”这样无力的话语&#xff0c;无数次在年轻人的脑海中回响&#xff0c;尤其是在那些因地域差异而面临教育资源匮乏的年轻人中更为普遍。在中国…

企业级WEB应用服务器——TOMCAT

一、WEB技术 1.1、HTTP协议和B/S 结构 最早出现了CGI&#xff08;Common Gateway Interface&#xff09;通用网关接口&#xff0c;通过浏览器中输入URL直接映射到一个 服务器端的脚本程序执行&#xff0c;这个脚本可以查询数据库并返回结果给浏览器端。这种将用户请求使用程…

AWS不同类型的EC2实例分别适合哪些场景?

Amazon Web Services&#xff08;AWS&#xff09;的弹性计算云&#xff08;EC2&#xff09;提供了多种实例类型&#xff0c;以满足不同的应用需求和工作负载。了解不同类型的 EC2 实例及其适用场景&#xff0c;可以帮助用户更好地优化性能和控制成本。九河云和大家一起了解一下…

安恒信息总裁宋端智,辞职了!活捉一枚新鲜出炉的餐饮人!

吉祥知识星球http://mp.weixin.qq.com/s?__bizMzkwNjY1Mzc0Nw&mid2247485367&idx1&sn837891059c360ad60db7e9ac980a3321&chksmc0e47eebf793f7fdb8fcd7eed8ce29160cf79ba303b59858ba3a6660c6dac536774afb2a6330#rd 《网安面试指南》http://mp.weixin.qq.com/s?…

I/O模型

文章目录 I/O模型相关概念网络I/O模型阻塞型I/O模型非阻塞型I/O模型多路复用I/O型信号驱动式I/O型异步I/O模型 apache和nginx的区别&#xff0c;什么时候选择apache&#xff0c;什么时候选择nginx 文章相关连接如下&#xff1a; 如果想更多了解nginx&#xff0c;请点击&#x…

为什么要使用TikTok云手机

随着TikTok平台的日益繁荣&#xff0c;TikTok云手机作为一种新兴的运营工具&#xff0c;正以其独特的云端技术和用户体验&#xff0c;赢得广大用户的青睐。相较于传统手机&#xff0c;TikTok云手机通过云端技术为用户带来了一系列新的优势&#xff0c;让TikTok运营变得更加灵活…

涂料耐久性氙灯老化试验箱

涂料氙灯老化试验箱是现代检测手段中常用的一种设备&#xff0c;它能够模拟自然光照、光照老化等环境条件&#xff0c;对涂料、染料、塑料、橡胶、纺织品、涂层等材料进行老化试验&#xff0c;以评估其耐久性和使用寿命。本文将详细介绍涂料氙灯老化试验箱的工作原理、使用注意…

正则表达式——详解

正则表达式是什么&#xff1f; 正则表达式&#xff08;Regular Expression&#xff0c;通常简写为 regex、regexp 或 RE&#xff09;是一种强大的文本处理工具&#xff0c;用于描述一组字符串的模式。它可以用来匹配、查找、替换等操作&#xff0c;几乎所有现代编程语言都支持…

【流媒体】RTMPDump—RTMP_Connect函数(握手、网络连接)

目录 1. RTMP_Connect函数1.1 网络层连接&#xff08;RTMP_Connect0&#xff09;1.2 RTMP连接&#xff08;RTMP_Connect1&#xff09;1.2.1 握手&#xff08;HandShake&#xff09;1.2.2 RTMP的NetConnection&#xff08;SendConnectPacket&#xff09; 2.小结 RTMP协议相关&am…

2024计算机软考报名流程(电脑报名)

1.24年下半年软考报名时间&#xff0c;各省报名时间不一样&#xff0c; 报名时间大概集中在&#xff1a;24年8月19日&#xff5e;24年9月15日&#xff1b; 报名网站&#xff1a;中国计算机技术职业资格网&#xff1b; 广东&#xff1a;2024年8月21日9:00至29日17:00 安徽&#…

Vue3 的 expose 介绍

在 Vue 3 中&#xff0c;expose 是一个用于控制组件内部方法和属性暴露给父组件的新功能。这使得父组件可以调用子组件内部的方法或访问其数据&#xff0c;尤其在使用组合式 API&#xff08;Composition API&#xff09;时&#xff0c;这种能力非常有用。 1. 基本用法 expose…

[PHP]-Laravel中Group By引发的问题思考

Laravel 和 ThinkPHP 是两个不同的 PHP 框架&#xff0c;它们在底层使用了相同的 SQL 查询语言来与数据库交互。然而&#xff0c;由于框架的设计和实现方式不同&#xff0c;它们在生成 SQL 查询时可能会表现出一些细微的差异&#xff0c;包括对 GROUP BY 子句的处理。 在调用查…