• 【C++ 程序设计】实战：C++ 实践练习题（21~30）

    目录

    21. 计算并输出 1 到 9 之间奇数之和

    22. 多层嵌套计算

    23. 循环结构：打印变量 a、b、c

    24. 函数调用：全局变量、局部变量

    25. 找到数组中不等于最大值和最小值的元素

    26. 计算：平方根、平方、立方根、立方

    27. 找出三个整型数中的最大值

    28. 初始化一个 5x5 的二维数组 a，根据表达式 (i + 1) * (j + 1) 将数组元素设置为 i * j，然后按矩阵形式输出这个二维数组

    29. 统计字符的个数并保存进文件中

    30. 递归方法：计算从 0 到 10 的阶乘

    21. 计算并输出 1 到 9 之间奇数之和

    1. #include 
    2.  
    3. int main()
    4. {
    5.     int i, s = 0;
    6.  
    7.     // 循环从1到9，每次增加2
    8.     for (i = 1; i < 10; i += 2)
    9.     {
    10.         // 将 i+1 的值加到变量 s 上
    11.         s += i + 1;
    12.     }
    13.  
    14.     // 输出变量 s 的值
    15.     printf("%d\n", s);
    16.  
    17.     return 0;
    18. }

    【代码详解】

    • 这段代码的作用是计算并输出 1 到 9 之间（包括 1 和 9）的奇数之和。、

    1. 包含头文件 ，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。

    2. main() 函数是 C++ 程序的入口函数。

    3. 声明了两个整型变量 i 和 s，并将 s 初始化为 0。

    4. for 循环语句初始化 i = 1，设置循环条件 i < 10，每次迭代增加 2。

    5. 循环体内的语句 s += i + 1 将迭代变量 i 加 1 的结果加到 s 上，相当于将奇数加到 s 中。

    6. printf("%d\n", s); 使用 printf 函数输出 s 的值，并换行。

    7. 返回 0，表示程序正常运行结束。

    【计算过程】

    1. 代码执行结果为 30。
    2. 原因是在循环中，变量 i 从 1 开始，每次增加 2，所以循环的迭代包括了 1, 3, 5, 7, 9 这五个奇数。
    3. 在循环体内部，将 i+1 的值加到变量 s 上，即 s += i + 1。
    4. 所以循环体执行过程如下：
    • 第一次迭代，i=1，将 1+1=2 加到 s 上，s 变为 2。
    • 第二次迭代，i=3，将 3+1=4 加到 s 上，s 变为 6。
    • 第三次迭代，i=5，将 5+1=6 加到 s 上，s 变为 12。
    • 第四次迭代，i=7，将 7+1=8 加到 s 上，s 变为 20。
    • 第五次迭代，i=9，将 9+1=10 加到 s 上，s 变为 30。

    【执行结果】

    30

    22. 多层嵌套计算

    1. #include 
    2.  
    3. int main()
    4. {
    5.     int x = 15, y = 21, z = 0;
    6.  
    7.     // 根据 x 对 3 取余数进行判断
    8.     switch (x % 3)
    9.     {
    10.         case 0: 
    11.             z++; // 如果余数为 0，z 的值加 1
    12.             break;
    13.         case 1: 
    14.             z++; // 如果余数为 1，z 的值加 1
    15.  
    16.             // 根据 y 对 2 取余数进行判断
    17.             switch (y % 2)
    18.             {
    19.                 default: 
    20.                     z++; // 如果余数不是 0，z 的值加 1
    21.                 case 0: 
    22.                     z++; // 如果余数为 0，z 的值加 1
    23.                     break;
    24.             }
    25.     }
    26.     printf("%d\n", z); // 输出变量 z 的值
    27.  
    28.     return 0;
    29. }

    【代码详解】

    • 这段代码的功能是根据给定的 x 和 y 的值，通过多层嵌套的 switch 语句来计算变量 z 的值，并将其输出。

    1. 包含头文件 ，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。

    2. main() 函数是 C++ 程序的入口函数。

    3. 声明了三个整型变量 x、y 和 z，并将分别赋值为 15、21 和 0。

    4. 第一个 switch 语句根据 x 对 3 取余数进行判断。

    5. 在第一个 switch 语句中，使用 case 语句根据余数的不同执行相应的操作。

    6. 如果余数为 0，执行 case 0，将 z 的值加 1。

    7. 如果余数为 1，执行 case 1，将 z 的值加 1，然后进入另一个嵌套的 switch 语句。

    8. 第二个 switch 语句根据 y 对 2 取余数进行判断。

    9. 在第二个 switch 语句中，使用 case 语句根据余数的不同执行相应的操作。

    10. 如果余数不是 0，执行 default（默认），将 z 的值加 1。

    11. 如果余数为 0，执行 case 0，将 z 的值加 1。

    12. 最后，使用 printf 函数输出变量 z 的值。

    【执行结果】

    • 执行结果为 1。
    • 假设 x = 15，对 x 取余数得到 0。因此不执行 case 1 的代码。执行 case 0 的代码，将 z 的值加 1，此时 z = 1。
    • 然后打印 z 的值，输出为 1。
    • 因此，最终输出的结果是 1。
    1

    23. 循环结构：打印变量 a、b、c

    1. #include 
    2.  
    3. int main()
    4. {
    5.     int a = 0, b = 5, c = 3;
    6.     
    7.     while (c > 0 && a < 5)
    8.     {
    9.         b = b - 1;  // 将 b 的值减 1
    10.         ++a;        // 将 a 的值加 1
    11.         c--;        // 将 c 的值减 1
    12.     }
    13.     
    14.     printf("%d, %d, %d\n", a, b, c);  // 输出变量 a、b、c 的值
    15.     
    16.     return 0;
    17. }

    【代码详解】

    • 这段代码的功能是根据给定的初始值，依次执行循环内的操作，并将最终的变量 a、b、c 的值打印出来。

    1. 包含头文件 ，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。

    2. main() 函数是 C++ 程序的入口函数。

    3. 声明了三个整型变量 a、b、c，并分别赋值为 0、5、3。

    4. while 循环语句的循环条件是 c > 0 && a < 5，只要 c 大于 0 并且 a 小于 5，就会执行循环体内的操作。

    5. 在循环体内，b 的值减 1，相当于将 b 减 1。

    6. ++a 表示将 a 的值加 1。

    7. c-- 表示将 c 的值减 1。

    8. 当循环条件不再满足时，跳出循环。

    9. 使用 printf 函数打印输出变量 a、b、c 的值。

    【执行结果】

    1. 执行结果根据初始值的不同而有所变化，具体结果取决于 a、b 和 c 的最终值。

    2. 例如，如果循环体被执行了 3 次，那么输出结果可能是 3, 2, 0。

    3, 2, 0

    24. 函数调用：全局变量、局部变量

    1. #include 
    2.  
    3. int z = 5;  // 全局变量 z
    4.  
    5. void f()
    6. {
    7.     static int x = 2;  // 静态局部变量 x，只会初始化一次
    8.     int y = 5;         // 局部变量 y
    9.  
    10.     x = x + 2;    // x 的值加 2
    11.     z = z + 5;    // z 的值加 5
    12.     y = y + z;    // y 的值加上 z 的值
    13.  
    14.     printf("%5d%5d\n", x, z);  // 输出变量 x 和 z 的值
    15. }
    16.  
    17. int main()
    18. {
    19.     static int x = 10;  // 静态局部变量 x，只会初始化一次
    20.     int y;
    21.  
    22.     y = z;  // 将全局变量 z 的值赋给局部变量 y
    23.  
    24.     printf("%5d%5d\n", x, z);  // 输出变量 x 和 z 的值
    25.     f();  // 调用函数 f()
    26.     printf("%5d%5d\n", x, z);  // 输出变量 x 和 z 的值
    27.     f();  // 再次调用函数 f()
    28.  
    29.     return 0;
    30. }

    【代码详解】

    • 这段代码使用了全局变量和局部变量，并展示了函数的调用。

    1. 声明了一个全局变量 z，初始值为 5。

    2. 定义了函数 f()。

    3. 在 f() 函数内部，声明了一个静态局部变量 x，初始值为 2，静态局部变量只会初始化一次。

    4. 在 f() 函数内部，声明了一个局部变量 y，初始值为 5。

    5. 在 f() 函数内部，对静态局部变量 x 进行操作，将其值加 2。

    6. 在 f() 函数内部，对全局变量 z 进行操作，将其值加 5。

    7. 在 f() 函数内部，对局部变量 y 进行操作，将其值加上全局变量 z 的值。

    8. 使用 printf 函数打印输出变量 x 和 z 的值。

    9. 定义了 main() 函数。

    10. 在 main() 函数内部，定义了一个静态局部变量 x，初始值为 10，静态局部变量只会初始化一次。

    11. 在 main() 函数内部，声明了一个局部变量 y。

    12. 将全局变量 z 的值赋给局部变量 y。

    13. 使用 printf 函数打印输出变量 x 和 z 的值。

    14. 调用函数 f()。

    15. 使用 printf 函数打印输出变量 x 和 z 的值。

    16. 再次调用函数 f()。

    【执行结果

    1.    10    5
    2.     4   10
    3.    10   10
    4.     6   15

    25. 找到数组中不等于最大值和最小值的元素

    1. #include 
    2.  
    3. struct prob
    4. {
    5.     const char* a;  // 字符串类型改为 const char* 类型
    6.     int b;
    7. } x[] = {{"Zhang San", 19}, 
    8.          {"Li Si", 21}, 
    9.          {"Wang Wu", 20}};
    10.  
    11. int main()
    12. {
    13.     int i, m1, m2;
    14.     m1 = m2 = x[0].b;  // 初始化 m1 和 m2 为数组第一个元素的 b 值
    15.     
    16.     for (i = 1; i < 3; i++)
    17.     {
    18.         if (x[i].b > m1)
    19.             m1 = x[i].b;  // 更新 m1 为更大的 b 值
    20.         else if (x[i].b < m2)
    21.             m2 = x[i].b;  // 更新 m2 为更小的 b 值
    22.     }
    23.     
    24.     for (i = 0; i < 3; i++)
    25.     {
    26.         if (x[i].b != m1 && x[i].b != m2)
    27.         {
    28.             printf("%s:%d\n", x[i].a, x[i].b);  // 输出不等于 m1 和 m2 的元素的 a 和 b 值
    29.             break;
    30.         }
    31.     }
    32.     
    33.     return 0;
    34. }

    【代码详解】

    • 代码的功能是找到数组中不等于最大值和最小值的元素，并将其输出。
    • 请注意，为了使用 printf 函数，需要包含适当的头文件  或 。

    1. 定义了一个名为 prob 的结构体，其中包括一个 const char* 类型的字符串指针 a 和一个整型变量 b。

    2. 创建一个 prob 结构体类型的数组 x，并对其进行初始化，数组中的每个元素包括一个字符串和一个整数。

    3. 在 main 函数中，声明了一些整型变量 i、m1 和 m2。

    4. 将数组第一个元素的 b 值分别赋给 m1 和 m2，即初始化 m1 和 m2。

    5. 使用 for 循环遍历数组，从索引为 1 的元素开始，依次判断每个元素的 b 值是否比 m1 大，如果是，则更新 m1 为该值；如果不是，则判断是否比 m2 小，如果是，则更新 m2 为该值。

    6. 使用另外一个 for 循环遍历数组，与之前的循环类似，但这次是用来查找不等于 m1 和 m2 的元素。当找到符合条件的元素时，使用 printf 函数将其对应的 a 和 b 值打印输出，并使用 break 终止循环。

    7. 最后，返回整数值 0 表示程序执行成功结束。

    【执行结果】

    • 执行结果将输出不等于最大值 m1 和最小值 m2 的元素的 a 和 b 值。
    • 由于数组 x 中的元素顺序是固定的，可以确定 m1 和 m2 的值，然后在循环中找到不等于这两个值的元素进行输出。
    • 根据数组的初始化，m1 的初始值为 21，m2 的初始值为 19。根据代码逻辑，应该输出 Wang Wu:20，这是因为它是唯一一个既不等于 m1 也不等于 m2 的元素。
    Wang Wu:20

    26. 计算：平方根、平方、立方根、立方

    【题目】 为实型变量 x 输入一个值后，输出 x 的值、x 的平方根、x 的平方、x 的立方根和 x的立方。

    1. #include  // 输入输出流头文件
    2. #include     // 数学函数头文件
    3.  
    4. int main() {
    5.     double x;
    6.     std::cout << "请输入实数 x 的值："; // 提示用户输入实数 x 的值
    7.     std::cin >> x; // 从用户输入读取实数 x 的值
    8.  
    9.     double squareRoot = std::sqrt(x); // 计算 x 的平方根
    10.     double square = std::pow(x, 2);   // 计算 x 的平方
    11.     double cubeRoot = std::cbrt(x);   // 计算 x 的立方根
    12.     double cube = std::pow(x, 3);     // 计算 x 的立方
    13.  
    14.     std::cout << "x 的值：" << x << std::endl;                      // 输出 x 的值
    15.     std::cout << "x 的平方根：" << squareRoot << std::endl;         // 输出 x 的平方根
    16.     std::cout << "x 的平方：" << square << std::endl;               // 输出 x 的平方
    17.     std::cout << "x 的立方根：" << cubeRoot << std::endl;           // 输出 x 的立方根
    18.     std::cout << "x 的立方：" << cube << std::endl;                 // 输出 x 的立方
    19.  
    20.     return 0; // 程序执行完毕，返回 0 表示成功
    21. }

    【代码详解】

    • 代码的功能是：用户输入一个实数 x 的值，然后计算并输出 x 的值、平方根、平方、立方根和立方。
    • 代码中使用了 cmath 头文件中的函数 sqrt()、pow() 和 cbrt() 来计算平方根、幂和立方根。
    • 请注意，为了使用输入输出流和数学函数，需要包含适当的头文件  和 。

    1. 包含了  和  两个头文件，分别用于输入输出流和数学函数的声明。

    2. 在 main 函数中声明了一个 double 类型的变量 x，用于存储用户输入的实数值。

    3. 使用 std::cout 输出提示信息，要求用户输入实数 x 的值。

    4. 使用 std::cin 从用户输入读取实数 x 的值，并将其存储到变量 x 中。

    5. 声明了四个 double 类型的变量 squareRoot、square、cubeRoot 和 cube，用于保存计算结果。

    6. 使用 std::sqrt(x) 计算 x 的平方根，并将结果赋给 squareRoot。

    7. 使用 std::pow(x, 2) 计算 x 的平方，并将结果赋给 square。

    8. 使用 std::cbrt(x) 计算 x 的立方根，并将结果赋给 cubeRoot。

    9. 使用 std::pow(x, 3) 计算 x 的立方，并将结果赋给 cube。

    10. 使用 std::cout 输出 x 的值、平方根、平方、立方根和立方，分别带有相应的提示信息。

    11. 返回整数值 0 表示程序执行成功结束。

    【执行结果】

    • 键盘输入示例： 
      请输入实数 x 的值：5.7
    • 执行结果输出示例： 
      1. x 的值：5.7
      2. x 的平方根：2.38747
      3. x 的平方：32.49
      4. x 的立方根：1.78632
      5. x 的立方：185.193

    27. 找出三个整型数中的最大值

    【题目】输入三个整型数，找出其中数值最大者并输出。

    1. #include 
    2.  
    3. int main() {
    4.     int a, b, c;
    5.  
    6.     std::cout << "请输入三个整数: ";  // 提示用户输入三个整数
    7.     std::cin >> a >> b >> c;        // 从用户输入读取三个整数
    8.  
    9.     int max = a;  // 假设第一个整数 a 是最大值
    10.  
    11.     if (b > max) {
    12.         max = b;  // 如果第二个整数 b 大于当前最大值，则更新最大值为 b
    13.     }
    14.  
    15.     if (c > max) {
    16.         max = c;  // 如果第三个整数 c 大于当前最大值，则更新最大值为 c
    17.     }
    18.  
    19.     std::cout << "最大值是: " << max << std::endl;  // 输出最大值
    20.  
    21.     return 0;  // 程序执行完毕，返回 0 表示成功
    22. }

    【代码详解】

    • 代码的功能是：用户输入三个整数，通过比较找出其中的最大值，并将其输出。
    • 请注意，代码中使用了三个变量 a、b、c 分别表示输入的三个整数，并使用 if 条件语句和比较操作符 > 来判断最大值。

    1. 包含了  头文件，用于输入输出流的声明。

    2. 在 main 函数中声明了三个整数变量 a、b、c，用于存储用户输入的三个整数值。

    3. 使用 std::cout 输出提示信息，要求用户输入三个整数。

    4. 使用 std::cin 从用户输入读取三个整数，并分别将它们存储到变量 a、b、c 中。

    5. 声明了一个整数变量 max，并将其初始值设为 a，即假设第一个整数 a 是最大值。

    6. 使用 if 条件语句和比较操作符 > 对变量 max 进行更新：

      • 如果第二个整数 b 大于当前最大值 max，则将 max 更新为 b。
      • 如果第三个整数 c 大于当前最大值 max，则将 max 更新为 c。

    7. 使用 std::cout 输出最大值，并附带相应的提示信息。

    8. 返回整数值 0 表示程序执行成功结束。

    【执行结果】

    • 键盘输入示例:
    请输入三个整数: 55 329 2
    • 执行结果输出示例:
    最大值是: 329

    28. 初始化一个 5x5 的二维数组 a，根据表达式 (i + 1) * (j + 1) 将数组元素设置为 i * j，然后按矩阵形式输出这个二维数组

    【题目】使用二维数组形成并按下列形式输出数据

    1. #include 
    2.  
    3. int main()
    4. {
    5.     int i, j, a[5][5];
    6.  
    7.     // 使用两层循环初始化二维数组 a
    8.     for (i = 0; i < 5; i++)
    9.         // 在两层循环中，使用表达式 (i + 1) * (j + 1) 将数组元素的值进行初始化，即将数组中的每个元素设置为 i * j。
    10.         for (j = 0; j < 5; j++) a[i][j] = (i + 1) * (j + 1);  
    11.  
    12.     // 输出二维数组 a 的元素
    13.     for (i = 0; i < 5; i++)
    14.     {
    15.         // 使用 printf("%2d ", a[i][j]) 来输出二维数组 a 中的元素，其中 %2d 表示输出一个两位数的整数，并用空格进行对齐。
    16.         for (j = 0; j < 5; j++) printf("%2d ", a[i][j]); 
    17.         // 在每一行输出结束之后，使用 printf("\n") 来换行，使输出结果呈现矩阵的形式。
    18.         printf("\n"); 
    19.     }
    20.  
    21.     return 0;
    22. }

    【代码详解】

    • 代码的功能是：初始化一个 5x5 的二维数组 a，根据表达式 (i + 1) * (j + 1) 将数组元素设置为 i * j，然后按矩阵形式输出这个二维数组。

    1. 包含了  头文件，用于标准输入输出函数的声明。

    2. 在 main 函数中声明了三个整数变量 i、j、a[5][5]。

    3. 使用两个嵌套的循环，对二维数组 a 进行初始化：

      • 外层循环控制行数，变量 i 的初始值为 0，每次循环增加 1，循环条件为 i < 5。
      • 内层循环控制列数，变量 j 的初始值为 0，每次循环增加 1，循环条件为 j < 5。
      • 在内层循环中，使用表达式 (i + 1) * (j + 1) 将数组元素的值进行初始化，即将数组中的每个元素设置为 i * j。

    4. 使用两个嵌套的循环，输出二维数组 a 的元素：

      • 外层循环控制行数，变量 i 的初始值为 0，每次循环增加 1，循环条件为 i < 5。
      • 内层循环控制列数，变量 j 的初始值为 0，每次循环增加 1，循环条件为 j < 5。
      • 在内层循环中，使用 printf("%2d ", a[i][j]) 来输出二维数组 a 中的元素，其中 %2d 表示输出一个两位数的整数，并用空格进行对齐。
      • 在每一行输出结束之后，使用 printf("\n") 来换行，使输出结果呈现矩阵的形式。

    5. 返回整数值 0 表示程序执行成功结束。

    【执行结果】

    1.  1  2  3  4  5
    2.  2  4  6  8 10
    3.  3  6  9 12 15
    4.  4  8 12 16 20
    5.  5 10 15 20 25

    29. 统计字符的个数并保存进文件中

    【题目】 键入一串字符（换行作为结束标志），统计字符的个数，将该串字符及字符个数显示到屏幕上并写入文件 str. dat 中。

    1. #include 
    2.  
    3. int main()
    4. {
    5.     char ch;
    6.     int sumch = 0;
    7.     FILE *fp;
    8.     
    9.     // 打开文件 "str.dat"，并以写入模式打开
    10.     if (fopen_s(&fp, "str.dat", "w") != 0)
    11.     {
    12.         printf("Failed to open the file.\n");
    13.         return 1;
    14.     }
    15.  
    16.     // 循环读取用户输入的字符，直到遇到换行符为止
    17.     while ((ch = getchar()) != '\n') 
    18.     {
    19.         sumch++;  // 字符计数器自增
    20.         putchar(ch);  // 输出字符到屏幕
    21.         fputc(ch, fp);  // 写入字符到文件
    22.     }
    23.  
    24.     printf("sumch=%d\n", sumch);  // 输出字符的个数到屏幕
    25.     fprintf(fp, "sumch=%d\n", sumch);  // 将格式化后的字符串写入文件
    26.     fclose(fp);  // 关闭文件
    27.     
    28.     return 0;
    29. }

    【代码详解】

    • 这段代码的功能是从标准输入读取字符，并统计字符的个数，并将字符打印在屏幕上和写入到名为 “str.dat” 的文件中。程序还会输出字符的个数。如果文件打开失败，则会输出一条错误信息。

    1. 包含了  头文件，用于标准输入输出函数的声明。

    2. 在 main 函数中声明了字符变量 ch，整数变量 sumch，以及 FILE 类型的指针变量 fp。

    3. 使用 fopen_s 函数打开名为 “str.dat” 的文件，并以写入模式 "w" 打开，将文件指针返回给 fp 变量。

      • 使用 fopen_s 函数可以更安全地打开文件，避免潜在的安全问题。

    4. 使用 if 条件判断语句检查文件是否成功打开。

      • 如果 fopen_s 函数返回非零值，则说明文件打开失败，输出一条错误信息并返回非零值。

    5. 使用一个循环，读取用户输入的字符并执行相应的操作，直到遇到换行符 '\n' 为止：

      • 循环条件是 (ch = getchar()) != '\n'，表示当从标准输入中读取到的字符不是换行符时，继续循环。
      • 在循环体中，字符计数器 sumch 自增，将读取到的字符输出到屏幕上使用 putchar(ch) 函数，将字符写入到文件中使用 fputc(ch, fp) 函数。

    6. 使用 printf 函数在屏幕上输出字符的个数。

    7. 使用 fprintf 函数将格式化后的字符串写入文件中，格式化的字符串为 "sumch=%d\n"，其中 %d 表示一个整数，将 sumch 变量的值插入到字符串中。

    8. 使用 fclose 函数关闭文件。

    9. 返回整数值 0 表示程序执行成功结束。

    【执行结果】

    • 键盘输入示例: 
      wueyoiwuepwoejwkfldkf.sqwuoqwio都弄去问候
    • 执行结果输出示例: 
      wueyoiwuepwoejwkfldkf.sqwuoqwio都弄去问候sumch=41

    30. 递归方法：计算从 0 到 10 的阶乘

    【题目】用递归方法写出计算 n 的阶乘的函数，调用该函数计算并输出 n=0, 1, 2, ……, 10 时各阶乘的值。

    • 计算公式：

    （1）当 n=0,1 时，n! = 1

    （2）当 n＞1 时，  n! = nx(n-1)!

    1. #include 
    2.  
    3. // 递归计算阶乘函数
    4. long fac(int n) {
    5.     // 当 n=0,1 时，n! = 1
    6.     if (n == 0 || n == 1) 
    7.         return 1;
    8.     else
    9.         // 当 n>1 时，n! = n*(n-1)!
    10.         return n * fac(n - 1); 
    11. }
    12.  
    13. int main() {
    14.     int n;
    15.     long int result;
    16.     for (n = 0; n <= 10; n++) {
    17.         // 调用 fac 函数计算阶乘值
    18.         result = fac(n);
    19.         // 输出阶乘结果
    20.         std::cout << n << "! = " << result << std::endl;
    21.     }
    22.     return 0;
    23. }

    【代码详解】

    1. 这段代码通过递归的方式计算了从 0 到 10 的阶乘，并输出了结果。
    2. 这段代码定义了一个递归函数 fac，它用于计算 n 的阶乘的值。
    3. 首先在 main 函数中，我们通过循环从 0 到 10 遍历不同的 n 值。
    4. 在循环中，调用 fac 函数计算当前 n 的阶乘值，并将结果赋给 result 变量。
    5. 最后，输出每个 n 的阶乘结果。

    【执行结果】

    1. 0! = 1
    2. 1! = 1
    3. 2! = 2
    4. 3! = 6
    5. 4! = 24
    6. 5! = 120
    7. 6! = 720
    8. 7! = 5040
    9. 8! = 40320
    10. 9! = 362880
    11. 10! = 3628800

  • 相关阅读:
    光泽正在褪去，所以我们又回到了人工智能领域。
    Sentinel：服务限流
    微服务之流控、容错组件sentinel
    SMP多核启动（一）：spin-table
    Flutter组件--Padding和AnimatedPadding
    外观缺陷检测原理
    Turbo译码部分的迭代停止准则
    蓝桥杯回文日期C语言
    性能测试笔记
    数据库的备份与恢复
  • 原文地址：https://blog.csdn.net/qq_39720249/article/details/132137050