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

目录

1 循环控制语句

2 while 循环      

2.1 语法格式

2.2 功能流程图

2.3 计数循环

2.3.1 实现原则

2.3.2 案例演示

2.4 不确定循环

3 do-while 循环

3.1 语法格式

3.2 功能流程图

3.3 计数循环

3.4 不确定循环

4 while 和 do while 的差异

4.1 语法结构差异

4.2 执行次数差异

4.3 适用场景差异

4.4 注意事项

5 for 循环

5.1 语法格式

5.2 功能流程图

5.3 执行顺序

5.4 计数循环

5.5 不确定性循环

5.6 简写的 for 循环

6 多重嵌套循环

6.1 介绍

6.2 执行总次数

6.3 案例:打印二维坐标

6.4 案例:打印九九乘法表的多种形式

7 死循环

7.1 使用 while 循环实现死循环

7.2 使用 for 循环实现死循环

7.3 注意事项

7.4 案例:使用死循环持续输入数据

8 测试题


1 循环控制语句

        在 C 语言中,循环控制是流程控制的重要组成部分,它允许一段代码在满足特定条件时重复执行。循环结构有助于编写简洁高效的代码来处理重复性任务。C 语言提供了几种常用的循环控制语句,包括 while 循环、do...while 循环、for 循环。这些循环语句能够有效地重复执行一段代码,直至某一条件不再满足,特别适用于处理需要多次迭代的任务,即使每次迭代的数据或条件有所不同。每种循环结构都有其特定的应用场景和语法特点。


2 while 循环      

2.1 语法格式

while (循环条件表达式)
{
    循环体语句;
}

        当循环条件表达式为真时,执行循环体语句,直到条件变为假时停止循环,即先判断后执行

        为了避免无限循环,循环条件应设计为随着每次循环迭代逐渐趋向于变为假

2.2 功能流程图

2.3 计数循环

2.3.1 实现原则

        在 C 语言中使用 while 实现计数循环时需要遵循以下三个基本原则:

1. 必须初始化循环变量

        在进入while 循环之前,必须首先为循环变量赋予一个初始值。这个初始值通常是计数循环的起点。例如,如果想要从 1 数到 10,就需要在循环开始前将循环变量(比如命名为 count)初始化为 1。这个初始化确保了循环有一个明确的起点,从而可以按照预定的方式开始计数

2. 循环变量比较作为循环条件

        while 循环的循环条件是一个布尔表达式,它决定了循环是否应该继续执行。在计数循环中,这个条件通常涉及对循环变量的比较。例如,如果想要一直执行循环体,直到循环变量达到或超过某个特定值。那么,循环条件可能类似于 count <= 10,这意味着只要 count 的值小于或等于 10,循环就会继续。这个条件确保了循环按照预定的次数执行。

3. 循环变量变化

        在循环体的末尾(或在循环体的某个地方,但必须在下一次迭代之前),必须更新循环变量的值。这通常是通过增加或减少循环变量(假设为 count)的值来实现的,具体取决于计数方向(向上计数还是向下计数)。我们可以通过 count++(即 count = count + 1)或 count-- 来更新循环变量的值。这个更新步骤是必不可少的,因为它确保了每次循环迭代后,循环条件都会被重新评估,并且如果条件仍然为真,则循环将继续执行。如果循环变量没有变化,循环将无限期地继续执行,这通常被称为 “无限循环”或 “死循环”,是编程中需要避免的情况,除非真的需要用到死循环

2.3.2 案例演示

案例一:循环输出多条语句

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

#include <stdio.h>

int main()
{
    // 定义循环变量,初始化为 1,表示从第 1 天开始计数
    int num = 1;

    while (num <= 10)
    {
        printf("我第%d天吃了%d个韭菜馅的包子 \n", num, num);

        // 循环标记变量变化,每次循环结束时 num 的值增加 1,为下一次循环准备条件
        num++;
    }

    // 循环结束后,打印循环变量的值。
    printf("循环结束后循环变量的值:%d", num);

    return 0;
}

        输出结果如下所示:

案例二:循环输出数字 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;
}

        输出结果如下所示:

案例三:倒序输出数字 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;
}

        输出结果如下所示:

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

#include <stdio.h>

int main()
{
    // 1. 通过控制循环变量来打印偶数(从 0 到 10,包括 0)
    // 这种方法直接在循环体内部修改循环变量 i 的值,从而避免不必要的循环迭代,提高效率
    int i = 0; 
    while (i <= 10) 
    {
        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)来跳过奇数,仅打印偶数。第二种方法则是在循环体内通过条件判断(使用取余运算符 %)来确定当前数字是否为偶数,并据此决定是否打印。两种方法各有特点,第一种方法在处理特定间隔(如偶数)时效率更高,因为它减少了循环迭代次数;而第二种方法则更加灵活,可以很容易地调整为打印奇数或其他基于条件的数字序列。 

        输出结果如下所示:

案例五:计算 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;
}

         输出结果如下所示:

案例六:计算 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;
}

        输出结果如下所示:

2.4 不确定循环

        不确定循环意味着在循环开始前,无法确切知道循环将会执行多少次,这取决于循环的条件何时变为假(false,0)。

        示例:输入 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;
}

        输出结果如下所示:


3 do-while 循环

3.1 语法格式

do
{
    循环体语句;
} while (循环条件表达式);  // 注意这里有分号;

        do...while 循环会先执行一次循环体,之后再判断条件。这意味着循环体至少会被执行一次,即便条件在最初就不成立。

        注意,while 后面的分号是必需的,不可省略

3.2 功能流程图

3.3 计数循环

        在 C 语言中使用 do-while 实现计数循环时同样需要遵循三个基本原则:1. 必须初始化循环变量;2. 循环变量比较作为循环条件;3. 循环变量变化

案例一:循环输出多条语句

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

#include <stdio.h>

int main()
{
    int i = 1;

    do
    {
        printf("我第 %d 天吃了 %d 个韭菜馅的包子 \n", i, i);
        i++;
    } while (i <= 10);

    // %i 等价于 %d
    printf("循环结束后循环变量的值: %i\n", i);

    return 0;
}

        输出结果如下所示:

案例二:循环输出数字 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;
}

        输出结果如下所示:

案例三:倒序输出数字 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; 
}

        输出结果如下所示: 

案例四:输出 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;
}

        输出结果如下所示:

案例五:计算 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;
}

         输出结果如下所示:

案例六:计算 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;
}

        输出结果如下所示: 

3.4 不确定循环

        不确定循环意味着在循环开始前,无法确切知道循环将会执行多少次,这取决于循环的条件何时变为假(false,0)。

        示例:输入 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;
}

        输出结果如下所示: 


4 while 和 do while 的差异

4.1 语法结构差异

        while 循环:其语法结构为 while (条件) {循环体语句}。它首先判断条件是否为真,如果为真,则执行循环体内的语句;然后再次判断条件,如此循环,直到条件为假时退出循环。

        do-while 循环:其语法结构为 do {循环体语句} while (条件);。它首先执行一次循环体内的语句,然后判断条件是否为真,如果为真,则继续执行循环体内的语句,如此循环,直到条件为假时退出循环。

4.2 执行次数差异

        while 循环在循环开始前就进行条件判断,如果条件一开始就不满足(即为假),则循环体内的语句一次也不会执行

        do-while 循环无论条件是否满足,都会至少执行一次循环体内的语句。这是因为条件判断是在执行完第一次循环体内的语句之后进行的。

4.3 适用场景差异

        while 循环适用于那些需要在条件满足时执行一段代码块的场景。如果一开始条件就不满足,则不会执行任何操作。

        do-while 循环适用于那些至少需要执行一次操作,然后再根据条件判断是否继续执行的场景。例如,读取用户输入或者进行一些必要的初始化操作。

4.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;
}

提示:

        遇到死循环时,可以通过使用 Ctrl+C 来中断程序的执行。


5 for 循环

5.1 语法格式

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

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

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

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

5.2 功能流程图

5.3 执行顺序

        for 循环的执行顺序如下:

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体
    // 这里是要重复执行的代码
}
  1. 首先执行循环变量初始化(只在循环开始时执行一次)。
  2. 接着检查循环条件表达式的值。
    • 如果条件为真(非零值),则执行循环体内的语句。
    • 如果条件为假(零值),则整个 for 循环结束。
  3. 每次循环体执行完毕后,执行循环变量变化表达式。
  4. 重复步骤 2 和 3,直到循环条件表达式为假。

5.4 计数循环

        在 C 语言中使用 for 实现计数循环时同样需要遵循三个基本原则:1. 必须初始化循环变量;2. 循环变量比较作为循环条件;3. 循环变量变化

案例一:使用三种循环输出 0-9 的整数

        下面这段代码展示了三种不同类型的循环:for 循环、while 循环和 do...while 循环。每种循环都用来打印从 0 到 9 的整数,并且在每次循环的最后输出一个换行符来区分不同循环的结果。

#include <stdio.h>

int main()
{
    // 使用 for 循环输出 0 到 9 的数字
    printf("for 循环:\t");
    for (int i = 0; i < 10; i++)
    {                           // 初始化变量 i 为 0,只要 i 小于 10 就继续循环,并且每次循环后 i 自增 1
        printf("i = %d \t", i); // 输出当前 i 的值
        if (i == 9)             // 当 i 达到 9 时换行
            printf("\n");
    }

    // 使用 while 循环输出 0 到 9 的数字
    printf("while 循环:\t");
    int i = 0; // 初始化 i 为 0
    while (i < 10)
    {                           // 只要 i 小于 10 就继续循环
        printf("i = %d \t", i); // 输出当前 i 的值
        if (i == 9)             // 当 i 达到 9 时换行
            printf("\n");
        i++; // 每次循环后 i 自增 1
    }

    // 使用 do-while 循环输出 0 到 9 的数字
    printf("do-while 循环:\t");
    int j = 0; // 初始化 j 为 0
    do
    {
        printf("j = %d \t", j); // 输出当前 j 的值
        if (j == 9)             // 当 j 达到 9 时换行
            printf("\n");
        j++; // 每次循环后 j 自增 1
    } while (j < 10); // 只要 j 小于 10 就继续循环

    return 0;
}

         输出结果如下所示:

案例二:循环输出多条语句

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

#include <stdio.h>

int main()
{
    for (int i = 1; i <= 10; i++)
    {
        printf("我第%d天吃了%d个韭菜馅的包子 \n", i, i);
    }

    return 0;
}

        输出结果如下所示:

案例三:循环输出数字 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++)
    {
        printf("%d \t", i);
    }

    return 0;
}

         输出结果如下所示:

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

#include <stdio.h>

int main()
{
    // 倒叙输出数字  56 ~ 43
    for (int i = 56; i >= 43; i--)
    {
        printf("%d \t", i);
    }
    return 0;
}

         输出结果如下所示:

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

#include <stdio.h>

int main()
{
    // 1. 通过控制循环变量来打印偶数
    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. 通过判断奇偶来打印偶数
    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;
}

        输出结果如下所示:

案例六:计算 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;
}

        输出结果如下所示:

 案例七:计算 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;
}

        输出结果如下所示:

5.5 不确定性循环

        不确定循环意味着在循环开始前,无法确切知道循环将会执行多少次,这取决于循环的条件何时变为假(false,0)。

        示例:输入 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;
}

        输出结果如下所示: 

5.6 简写的 for 循环

        在 C 语言中,for 循环的灵活性和多样性体现在其能够支持多种简写或变体结构,这些结构在编程实践中非常有用。首先,标准的 for 循环结构包括初始化表达式、条件表达式和迭代表达式,这三者均写在循环控制语句的圆括号内。然而,在某些情况下,我们可以通过省略这些表达式的一部分或全部,来形成 for 循环的特殊结构

        省略初始化表达式当循环变量已在循环外部初始化时,可以省略 for 循环中的初始化部分。这种结构在需要在循环外部进行复杂初始化时特别有用。

int i = 0;  
for (; i < 10; i++) {  
    // 循环体  
}

        省略循环条件表达式:省略循环条件表达式会导致一个无限循环,除非在循环体内部有某种方式(如 break 语句)来跳出循环

int i = 0;  
for (i = 0; ; i++) {  
    if (i >= 10) {  
        break; // 否则这将是一个无限循环  
    }  
    // 循环体  
}

        省略迭代表达式:省略迭代表达式时,循环变量不会自动更新,这同样可能导致无限循环,除非在循环体内部手动更新循环变量或使用其他方式(如 break)来跳出循环。在某些情况下,迭代逻辑可能较为复杂,不适合放在 for 循环的迭代表达式部分。此时,就可以将迭代逻辑放在循环体内部的大括号中。

#include <stdio.h>

int main()
{
    int i = 0; // 循环变量在循环外部初始化

    // 省略迭代表达式
    for (; i < 10; /* 空 */)
    {
        printf("%d ", i); // 输出:0 2 4 6 8

        i += 2; // 在循环体内更新循环变量
    }

    printf("\n");

    // 更复杂的迭代逻辑放在循环体内部
    int j = 0;
    for (; j < 10; /* 空 */)
    {
        if (j % 2 == 0)
        {   // 每隔一个数增加 2
            printf("%d ", j); // 输出: 0 2 4 6 8
            j += 2;
        }
        else
        {
            j++; // 如果不是偶数,只是简单地增加 1
        }
    }

    return 0;
}

        同时省略多个表达式若 for 循环的圆括号内多个表达式都省略,将形成一个无限循环。这通常用于需要等待某个条件成立才能退出的场景,但必须在循环体内有明确的退出条件(如 break 语句)以避免程序挂起,确保在适当的时候能够退出。

int i = 0;  
for (;;) { // 无限循环,需要内部逻辑来控制何时退出  
    if (i >= 10) {  
        break;  
    }  
    i++;  
    // 循环体  
}

        同时初始化多个变量for 循环的初始化表达式不仅可以用于初始化一个变量,还可以同时初始化多个变量。如下面代码中的最后的 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;)
    {
        if (i % 2 == 0)
        {                     // 每隔一个数增加 2
            printf("%d ", i); // 输出:2 4 6 8
            i += 2;
        }
        else
        {
            i++; // 如果不是偶数,只是简单地增加 1
        }
    }
    printf("\n\n");

    // 4. 所有内容都省略
    // for 括号中什么都不写,{}里面也没有明确的退出条件 ——> 死循环
    for (;;)
    {
        printf("死循环 \n"); // 无限次打印“死循环”
        // 注意:在实际应用中,应避免编写无限循环,除非有明确的退出条件(如 break 语句)
        break;
    }
    printf("\n");

    // 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,并设置循环条件
    // 逗号 , 是一个操作符,它用于顺序执行其两边的表达式,但整个逗号表达式的值是其右侧表达式的值。
    // 由于逗号操作符的特性,这个条件的最终评估结果只取决于 y > 6 的结果。
    for (int x = 1, y = 10; x < 6, y > 6; x++, y--)
    {
        printf("%d %d \n", x, y);
    }
    printf("\n");

    // && 连接
    for (int x = 1, y = 10; x < 6 && y > 7; x++, y--)
    {
        printf("%d %d \n", x, y);
    }
    printf("\n");
    // || 连接
    for (int x = 1, y = 10; x < 6 || y > 7; x++, y--)
    {
        printf("%d %d \n", x, y);
    }
    printf("\n");

    return 0;
}

        输出结果如下所示:


6 多重嵌套循环

6.1 介绍

        将一个循环放在另一个循环体内,就形成了嵌套循环, 其中,for、while、do…while 均可以作为外层循环和内层循环,建议一般使用两层,最多不要超过 3 层,如果嵌套循环过多,会造成可读性降低。

6.2 执行总次数

        如果外层循环次数为 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;
}

        输出结果如下所示:

6.3 案例:打印二维坐标

#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;
}

        输出结果如下所示:

6.4 案例:打印九九乘法表的多种形式

案例一:要求输出如下形式的九九乘法表

        题目分析:主要是搞清楚行和列的关系,从图中可以看出第一行只有一列,第二行只有两列……第九行只有九列,即是说列的数量要小于等于行的数量。即内层循环变量 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;
}

案例二:要求输出如下形式的九九乘法表

        题目分析:方法一:相比较第一种形式的九九乘法表,可以看出对称关系,即相当于把第一行变到了第九行,第二行变到了第八行……第九行变到了第一行,所以只需要将原来行号的变化进行修改,即把外层循环变量 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;
}

案例三:要求输出如下形式的九九乘法表

        题目分析:相比第一种形式的九九乘法表,相当于部分行的前面多了一些空格。所以需要先来一个循环进行空位的输出。第一行前面有八个制表位,第二行前面有七个制表位……第九行前面有零个制表位,所以若用 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;
}

案例四:要求输出如下形式的九九乘法表

        题目分析:相比第二种形式的九九乘法表,相当于部分行的前面多了一些空格。所以需要先来一个循环进行空位的输出。第一行前面有零个制表位,第二行前面有一个制表位……第九行前面有八个制表位,所以若用 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;
}

7 死循环

        在 C 语言中,死循环是指一个循环结构在执行过程中,由于循环条件永远为真(或者循环体中没有修改循环条件使其变为假的操作),导致循环体不断重复执行,从而无法自然终止的循环

        死循环在某些情况下是有用的,比如在需要程序持续运行直到外部干预(如用户输入、信号中断等)时。但是,如果死循环的使用不当,可能会导致程序无法正常结束,浪费系统资源,甚至造成程序崩溃。

        C 语言中常用的死循环有两种形式:while 循环和 for 循环。

7.1 使用 while 循环实现死循环

while (1) {  
    // 循环体  
    // 这里可以放置需要持续执行的代码  
}

        在这个例子中,循环条件被设置为 1,这是一个永远为真的表达式,因此循环体会不断重复执行。

7.2 使用 for 循环实现死循环

for (;;) {  
    // 循环体  
    // 这里可以放置需要持续执行的代码  
}

        for 循环的初始化表达式、条件表达式和迭代表达式都可以省略。当条件表达式省略时,它被视为永远为真,因此循环体会不断重复执行。

提示:

        再 VS Code 中可以使用快捷键 Ctrl + C 退出死循环!

7.3 注意事项

        明确目的确保死循环的使用有明确的目的,比如等待某个事件的发生、轮询任务等。避免无意义或错误地使用死循环导致资源浪费或程序逻辑混乱。

        退出机制为死循环提供明确的退出机制。这可以通过条件变量、信号量、中断处理或其他同步机制来实现。确保在需要时能够安全地退出循环,避免程序无法终止。

        资源管理:在死循环中,如果涉及到资源(如内存、文件句柄、网络连接等)的分配和使用,需要确保这些资源在不再需要时能够被正确释放,避免资源泄露。

        性能影响:考虑死循环对程序性能的影响。过紧的循环可能会消耗大量 CPU 资源,导致系统响应变慢或其他应用程序性能下降。可以通过在循环中添加适当的延时(如使用 sleep() 函数)来减轻这种影响。

        代码可读性:死循环的代码应该清晰易懂,特别是退出条件和资源管理的部分。良好的注释和文档可以帮助其他开发者理解循环的目的和逻辑。

        避免误用:确保死循环的使用是出于必要且无法用其他更优雅的方式(如事件驱动、回调等)实现。误用死循环可能会导致程序结构复杂、难以维护。

7.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 并按下了回车键为止。

        输出结果如下所示: 


8 测试题

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Thanks_ks

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值