目录
28. 初始化一个 5x5 的二维数组 a，根据表达式 (i + 1) * (j + 1) 将数组元素设置为 i * j，然后按矩阵形式输出这个二维数组
21. 计算并输出 1 到 9 之间奇数之和
#include <iostream>
int main()
{
int i, s = 0;
// 循环从1到9，每次增加2
for (i = 1; i < 10; i += 2)
{
// 将 i+1 的值加到变量 s 上
s += i + 1;
}
// 输出变量 s 的值
printf("%d\n", s);
return 0;
}【代码详解】
- 这段代码的作用是计算并输出 1 到 9 之间（包括 1 和 9）的奇数之和。、
包含头文件
<iostream>，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。
main()函数是 C++ 程序的入口函数。声明了两个整型变量
i和s，并将s初始化为 0。
for循环语句初始化i = 1，设置循环条件i < 10，每次迭代增加2。循环体内的语句
s += i + 1将迭代变量i加 1 的结果加到s上，相当于将奇数加到s中。
printf("%d\n", s);使用printf函数输出s的值，并换行。返回
0，表示程序正常运行结束。【计算过程】
- 代码执行结果为
30。- 原因是在循环中，变量
i从1开始，每次增加2，所以循环的迭代包括了1, 3, 5, 7, 9这五个奇数。- 在循环体内部，将
i+1的值加到变量s上，即s += i + 1。- 所以循环体执行过程如下：
- 第一次迭代，
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. 多层嵌套计算
#include <iostream>
int main()
{
int x = 15, y = 21, z = 0;
// 根据 x 对 3 取余数进行判断
switch (x % 3)
{
case 0:
z++; // 如果余数为 0，z 的值加 1
break;
case 1:
z++; // 如果余数为 1，z 的值加 1
// 根据 y 对 2 取余数进行判断
switch (y % 2)
{
default:
z++; // 如果余数不是 0，z 的值加 1
case 0:
z++; // 如果余数为 0，z 的值加 1
break;
}
}
printf("%d\n", z); // 输出变量 z 的值
return 0;
}【代码详解】
- 这段代码的功能是根据给定的
x和y的值，通过多层嵌套的switch语句来计算变量z的值，并将其输出。
包含头文件
<iostream>，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。
main()函数是 C++ 程序的入口函数。声明了三个整型变量
x、y和z，并将分别赋值为15、21和0。第一个
switch语句根据x对3取余数进行判断。在第一个
switch语句中，使用case语句根据余数的不同执行相应的操作。如果余数为
0，执行case 0，将z的值加1。如果余数为
1，执行case 1，将z的值加1，然后进入另一个嵌套的switch语句。第二个
switch语句根据y对2取余数进行判断。在第二个
switch语句中，使用case语句根据余数的不同执行相应的操作。如果余数不是
0，执行default（默认），将z的值加1。如果余数为
0，执行case 0，将z的值加1。最后，使用
printf函数输出变量z的值。【执行结果】
- 执行结果为
1。- 假设
x = 15，对x取余数得到0。因此不执行case 1的代码。执行case 0的代码，将z的值加1，此时z = 1。- 然后打印
z的值，输出为1。- 因此，最终输出的结果是
1。1
23. 循环结构：打印变量 a、b、c
#include <iostream>
int main()
{
int a = 0, b = 5, c = 3;
while (c > 0 && a < 5)
{
b = b - 1; // 将 b 的值减 1
++a; // 将 a 的值加 1
c--; // 将 c 的值减 1
}
printf("%d, %d, %d\n", a, b, c); // 输出变量 a、b、c 的值
return 0;
}【代码详解】
- 这段代码的功能是根据给定的初始值，依次执行循环内的操作，并将最终的变量 a、b、c 的值打印出来。
包含头文件
<iostream>，这是用于输入输出流的标准 C++ 头文件。在这个代码里没有直接使用，可以省略。
main()函数是 C++ 程序的入口函数。声明了三个整型变量
a、b、c，并分别赋值为0、5、3。
while循环语句的循环条件是c > 0 && a < 5，只要c大于0并且a小于5，就会执行循环体内的操作。在循环体内，
b的值减1，相当于将b减1。
++a表示将a的值加1。
c--表示将c的值减1。当循环条件不再满足时，跳出循环。
使用
printf函数打印输出变量a、b、c的值。【执行结果】
执行结果根据初始值的不同而有所变化，具体结果取决于
a、b和c的最终值。例如，如果循环体被执行了 3 次，那么输出结果可能是
3, 2, 0。3, 2, 0
24. 函数调用：全局变量、局部变量
#include <iostream>
int z = 5; // 全局变量 z
void f()
{
static int x = 2; // 静态局部变量 x，只会初始化一次
int y = 5; // 局部变量 y
x = x + 2; // x 的值加 2
z = z + 5; // z 的值加 5
y = y + z; // y 的值加上 z 的值
printf("%5d%5d\n", x, z); // 输出变量 x 和 z 的值
}
int main()
{
static int x = 10; // 静态局部变量 x，只会初始化一次
int y;
y = z; // 将全局变量 z 的值赋给局部变量 y
printf("%5d%5d\n", x, z); // 输出变量 x 和 z 的值
f(); // 调用函数 f()
printf("%5d%5d\n", x, z); // 输出变量 x 和 z 的值
f(); // 再次调用函数 f()
return 0;
}【代码详解】
- 这段代码使用了全局变量和局部变量，并展示了函数的调用。
声明了一个全局变量
z，初始值为5。定义了函数
f()。在
f()函数内部，声明了一个静态局部变量x，初始值为2，静态局部变量只会初始化一次。在
f()函数内部，声明了一个局部变量y，初始值为5。在
f()函数内部，对静态局部变量x进行操作，将其值加2。在
f()函数内部，对全局变量z进行操作，将其值加5。在
f()函数内部，对局部变量y进行操作，将其值加上全局变量z的值。使用
printf函数打印输出变量x和z的值。定义了
main()函数。在
main()函数内部，定义了一个静态局部变量x，初始值为10，静态局部变量只会初始化一次。在
main()函数内部，声明了一个局部变量y。将全局变量
z的值赋给局部变量y。使用
printf函数打印输出变量x和z的值。调用函数
f()。使用
printf函数打印输出变量x和z的值。再次调用函数
f()。【执行结果
10 5 4 10 10 10 6 15
25. 找到数组中不等于最大值和最小值的元素
#include <iostream>
struct prob
{
const char* a; // 字符串类型改为 const char* 类型
int b;
} x[] = {
{"Zhang San", 19},
{"Li Si", 21},
{"Wang Wu", 20}};
int main()
{
int i, m1, m2;
m1 = m2 = x[0].b; // 初始化 m1 和 m2 为数组第一个元素的 b 值
for (i = 1; i < 3; i++)
{
if (x[i].b > m1)
m1 = x[i].b; // 更新 m1 为更大的 b 值
else if (x[i].b < m2)
m2 = x[i].b; // 更新 m2 为更小的 b 值
}
for (i = 0; i < 3; i++)
{
if (x[i].b != m1 && x[i].b != m2)
{
printf("%s:%d\n", x[i].a, x[i].b); // 输出不等于 m1 和 m2 的元素的 a 和 b 值
break;
}
}
return 0;
}【代码详解】
- 代码的功能是找到数组中不等于最大值和最小值的元素，并将其输出。
- 请注意，为了使用
printf函数，需要包含适当的头文件<stdio.h>或<cstdio>。
定义了一个名为
prob的结构体，其中包括一个const char*类型的字符串指针a和一个整型变量b。创建一个
prob结构体类型的数组x，并对其进行初始化，数组中的每个元素包括一个字符串和一个整数。在
main函数中，声明了一些整型变量i、m1和m2。将数组第一个元素的
b值分别赋给m1和m2，即初始化m1和m2。使用
for循环遍历数组，从索引为 1 的元素开始，依次判断每个元素的b值是否比m1大，如果是，则更新m1为该值；如果不是，则判断是否比m2小，如果是，则更新m2为该值。使用另外一个
for循环遍历数组，与之前的循环类似，但这次是用来查找不等于m1和m2的元素。当找到符合条件的元素时，使用printf函数将其对应的a和b值打印输出，并使用break终止循环。最后，返回整数值
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的立方。
#include <iostream> // 输入输出流头文件
#include <cmath> // 数学函数头文件
int main() {
double x;
std::cout << "请输入实数 x 的值："; // 提示用户输入实数 x 的值
std::cin >> x; // 从用户输入读取实数 x 的值
double squareRoot = std::sqrt(x); // 计算 x 的平方根
double square = std::pow(x, 2); // 计算 x 的平方
double cubeRoot = std::cbrt(x); // 计算 x 的立方根
double cube = std::pow(x, 3); // 计算 x 的立方
std::cout << "x 的值：" << x << std::endl; // 输出 x 的值
std::cout << "x 的平方根：" << squareRoot << std::endl; // 输出 x 的平方根
std::cout << "x 的平方：" << square << std::endl; // 输出 x 的平方
std::cout << "x 的立方根：" << cubeRoot << std::endl; // 输出 x 的立方根
std::cout << "x 的立方：" << cube << std::endl; // 输出 x 的立方
return 0; // 程序执行完毕，返回 0 表示成功
}【代码详解】
- 代码的功能是：用户输入一个实数
x的值，然后计算并输出x的值、平方根、平方、立方根和立方。- 代码中使用了
cmath头文件中的函数sqrt()、pow()和cbrt()来计算平方根、幂和立方根。- 请注意，为了使用输入输出流和数学函数，需要包含适当的头文件
<iostream>和<cmath>。
包含了
<iostream>和<cmath>两个头文件，分别用于输入输出流和数学函数的声明。在
main函数中声明了一个double类型的变量x，用于存储用户输入的实数值。使用
std::cout输出提示信息，要求用户输入实数x的值。使用
std::cin从用户输入读取实数x的值，并将其存储到变量x中。声明了四个
double类型的变量squareRoot、square、cubeRoot和cube，用于保存计算结果。使用
std::sqrt(x)计算x的平方根，并将结果赋给squareRoot。使用
std::pow(x, 2)计算x的平方，并将结果赋给square。使用
std::cbrt(x)计算x的立方根，并将结果赋给cubeRoot。使用
std::pow(x, 3)计算x的立方，并将结果赋给cube。使用
std::cout输出x的值、平方根、平方、立方根和立方，分别带有相应的提示信息。返回整数值
0表示程序执行成功结束。【执行结果】
- 键盘输入示例：
请输入实数 x 的值：5.7- 执行结果输出示例：
x 的值：5.7 x 的平方根：2.38747 x 的平方：32.49 x 的立方根：1.78632 x 的立方：185.193
27. 找出三个整型数中的最大值
【题目】输入三个整型数，找出其中数值最大者并输出。
#include <iostream>
int main() {
int a, b, c;
std::cout << "请输入三个整数: "; // 提示用户输入三个整数
std::cin >> a >> b >> c; // 从用户输入读取三个整数
int max = a; // 假设第一个整数 a 是最大值
if (b > max) {
max = b; // 如果第二个整数 b 大于当前最大值，则更新最大值为 b
}
if (c > max) {
max = c; // 如果第三个整数 c 大于当前最大值，则更新最大值为 c
}
std::cout << "最大值是: " << max << std::endl; // 输出最大值
return 0; // 程序执行完毕，返回 0 表示成功
}【代码详解】
- 代码的功能是：用户输入三个整数，通过比较找出其中的最大值，并将其输出。
- 请注意，代码中使用了三个变量
a、b、c分别表示输入的三个整数，并使用if条件语句和比较操作符>来判断最大值。
包含了
<iostream>头文件，用于输入输出流的声明。在
main函数中声明了三个整数变量a、b、c，用于存储用户输入的三个整数值。使用
std::cout输出提示信息，要求用户输入三个整数。使用
std::cin从用户输入读取三个整数，并分别将它们存储到变量a、b、c中。声明了一个整数变量
max，并将其初始值设为a，即假设第一个整数a是最大值。使用
if条件语句和比较操作符>对变量max进行更新：
- 如果第二个整数
b大于当前最大值max，则将max更新为b。- 如果第三个整数
c大于当前最大值max，则将max更新为c。使用
std::cout输出最大值，并附带相应的提示信息。返回整数值
0表示程序执行成功结束。【执行结果】
- 键盘输入示例:
请输入三个整数: 55 329 2
- 执行结果输出示例:
最大值是: 329
28. 初始化一个 5x5 的二维数组 a，根据表达式 (i + 1) * (j + 1) 将数组元素设置为 i * j，然后按矩阵形式输出这个二维数组
【题目】使用二维数组形成并按下列形式输出数据
#include <stdio.h>
int main()
{
int i, j, a[5][5];
// 使用两层循环初始化二维数组 a
for (i = 0; i < 5; i++)
// 在两层循环中，使用表达式 (i + 1) * (j + 1) 将数组元素的值进行初始化，即将数组中的每个元素设置为 i * j。
for (j = 0; j < 5; j++) a[i][j] = (i + 1) * (j + 1);
// 输出二维数组 a 的元素
for (i = 0; i < 5; i++)
{
// 使用 printf("%2d ", a[i][j]) 来输出二维数组 a 中的元素，其中 %2d 表示输出一个两位数的整数，并用空格进行对齐。
for (j = 0; j < 5; j++) printf("%2d ", a[i][j]);
// 在每一行输出结束之后，使用 printf("\n") 来换行，使输出结果呈现矩阵的形式。
printf("\n");
}
return 0;
}【代码详解】
- 代码的功能是：初始化一个 5x5 的二维数组
a，根据表达式(i + 1) * (j + 1)将数组元素设置为i * j，然后按矩阵形式输出这个二维数组。
包含了
<stdio.h>头文件，用于标准输入输出函数的声明。在
main函数中声明了三个整数变量i、j、a[5][5]。使用两个嵌套的循环，对二维数组
a进行初始化：
- 外层循环控制行数，变量
i的初始值为 0，每次循环增加 1，循环条件为i < 5。- 内层循环控制列数，变量
j的初始值为 0，每次循环增加 1，循环条件为j < 5。- 在内层循环中，使用表达式
(i + 1) * (j + 1)将数组元素的值进行初始化，即将数组中的每个元素设置为i * j。使用两个嵌套的循环，输出二维数组
a的元素：
- 外层循环控制行数，变量
i的初始值为 0，每次循环增加 1，循环条件为i < 5。- 内层循环控制列数，变量
j的初始值为 0，每次循环增加 1，循环条件为j < 5。- 在内层循环中，使用
printf("%2d ", a[i][j])来输出二维数组a中的元素，其中%2d表示输出一个两位数的整数，并用空格进行对齐。- 在每一行输出结束之后，使用
printf("\n")来换行，使输出结果呈现矩阵的形式。返回整数值
0表示程序执行成功结束。【执行结果】
1 2 3 4 5 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 5 10 15 20 25
29. 统计字符的个数并保存进文件中
【题目】 键入一串字符（换行作为结束标志），统计字符的个数，将该串字符及字符个数显示到屏幕上并写入文件 str. dat 中。
#include <stdio.h>
int main()
{
char ch;
int sumch = 0;
FILE *fp;
// 打开文件 "str.dat"，并以写入模式打开
if (fopen_s(&fp, "str.dat", "w") != 0)
{
printf("Failed to open the file.\n");
return 1;
}
// 循环读取用户输入的字符，直到遇到换行符为止
while ((ch = getchar()) != '\n')
{
sumch++; // 字符计数器自增
putchar(ch); // 输出字符到屏幕
fputc(ch, fp); // 写入字符到文件
}
printf("sumch=%d\n", sumch); // 输出字符的个数到屏幕
fprintf(fp, "sumch=%d\n", sumch); // 将格式化后的字符串写入文件
fclose(fp); // 关闭文件
return 0;
}【代码详解】
- 这段代码的功能是从标准输入读取字符，并统计字符的个数，并将字符打印在屏幕上和写入到名为 “str.dat” 的文件中。程序还会输出字符的个数。如果文件打开失败，则会输出一条错误信息。
包含了
<stdio.h>头文件，用于标准输入输出函数的声明。在
main函数中声明了字符变量ch，整数变量sumch，以及FILE类型的指针变量fp。使用
fopen_s函数打开名为 “str.dat” 的文件，并以写入模式"w"打开，将文件指针返回给fp变量。
- 使用
fopen_s函数可以更安全地打开文件，避免潜在的安全问题。使用
if条件判断语句检查文件是否成功打开。
- 如果
fopen_s函数返回非零值，则说明文件打开失败，输出一条错误信息并返回非零值。使用一个循环，读取用户输入的字符并执行相应的操作，直到遇到换行符
'\n'为止：
- 循环条件是
(ch = getchar()) != '\n'，表示当从标准输入中读取到的字符不是换行符时，继续循环。- 在循环体中，字符计数器
sumch自增，将读取到的字符输出到屏幕上使用putchar(ch)函数，将字符写入到文件中使用fputc(ch, fp)函数。使用
printf函数在屏幕上输出字符的个数。使用
fprintf函数将格式化后的字符串写入文件中，格式化的字符串为"sumch=%d\n"，其中%d表示一个整数，将sumch变量的值插入到字符串中。使用
fclose函数关闭文件。返回整数值
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)!
#include <iostream>
// 递归计算阶乘函数
long fac(int n) {
// 当 n=0,1 时，n! = 1
if (n == 0 || n == 1)
return 1;
else
// 当 n>1 时，n! = n*(n-1)!
return n * fac(n - 1);
}
int main() {
int n;
long int result;
for (n = 0; n <= 10; n++) {
// 调用 fac 函数计算阶乘值
result = fac(n);
// 输出阶乘结果
std::cout << n << "! = " << result << std::endl;
}
return 0;
}【代码详解】
- 这段代码通过递归的方式计算了从 0 到 10 的阶乘，并输出了结果。
- 这段代码定义了一个递归函数
fac，它用于计算 n 的阶乘的值。- 首先在
main函数中，我们通过循环从 0 到 10 遍历不同的 n 值。- 在循环中，调用
fac函数计算当前 n 的阶乘值，并将结果赋给result变量。- 最后，输出每个 n 的阶乘结果。
【执行结果】
0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120 6! = 720 7! = 5040 8! = 40320 9! = 362880 10! = 3628800
