【C++ 程序设计】实战：C++ 实践练习题（11~20）

目录

11. 循环计数、变量赋值、递增运算

12. 递归序列 

13. 遍历输出结构体数组中每个元素的姓名和年龄

14.  指向整型变量的指针和一个整数作为参数

15. 从键盘读取字符，并执行操作，打印字符结果

16. 找出三位数中全部的水仙花数

17.  输入数字返回英文单词

18. 分科输入学生成绩计算总分、平均分

19.  创建一个 5x5 的二维数组，并按照指定形式输出数组的元素

20. 文件内容拷贝

---

---

11. 循环计数、变量赋值、递增运算

#include 

// 声明函数f的原型
void f(int j);

// 主函数
int main()
{
    int i;

    // 循环调用f函数两次
    for (i = 1; i < 3; i++)
    {
        f(i);
    }
}

// f函数定义
void f(int j)
{
    static int A = 100; // 静态变量A，初始值为100
    int k = 1;         // 局部变量k，初始值为1

    ++k;               // 对k进行自增操作
    printf("%d\n", j + A + k); // 打印j, A和k的和

    A -= 2;           // 对A进行减2操作
}

【代码详解】

1. #include ：包含标准输入输出头文件。

2. void f(int j);：函数 f() 的原型声明，告诉编译器函数 f() 的存在及其参数列表。

3. int main()：主函数的定义。

4. int i;：声明整型变量 i，用于循环计数。

5. for (i = 1; i < 3; i++)：循环语句，从 1 到 2 循环，每次循环调用 f() 函数。

6. void f(int j)：函数 f() 的定义，参数为整型 j。

7. static int A = 100;：静态变量 A，初始值为 100。静态变量是在函数调用过程中保持其值的变量。

8. int k = 1;：局部变量 k，初始值为 1。局部变量在函数每次调用时创建并初始化。

9. ++k;：对变量 k 进行自增操作，相当于 k = k + 1。

10. printf("%d\n", j + A + k);：使用 printf 函数输出格式化的字符串。将参数 j、A 和k 的值相加，作为格式化字符串的参数，其中 %d 是格式化符号，用于输出整数。

11. A -= 2;：对静态变量 A 进行减 2 操作，相当于 A = A - 2。

【计算过程】

• 上述代码的数学逻辑包括赋值运算、加法运算和减法运算，用于完成循环计数、变量赋值、递增运算和输出计算结果等任务
• 1+100+2 = 103
• 2+98+2 = 102

【执行结果】

• 该代码通过循环调用函数 f() 两次，每次调用会自增 k 的值，并将 j、A 和 k 的和输出。
• 每次调用函数 f() 后，静态变量 A 的值会减去 2。
• 最终的运行结果会输出 j + A + k 的和，每次结果都会换行打印出来。
• 因为循环调用了两次 f 函数，传入的参数分别是 1 和 2。
• 对于每次调用，j+A+k 的结果分别是 1+100+2=103 和 2+98+2 = 102，所以打印结果分别是 103 和 102。
• 静态变量 A 每次调用 f 函数时减去了 2。

103
102

---

12. 递归序列 

#include 

// 函数fun的定义
long fun(int n)
{
    long s; // 存储计算结果

    if (n <= 2)
        s = 2; // 当n小于等于2时，s的值为2
    else
        s = n + fun(n - 1); // 当n大于2时，s的值为n加上n-1的结果

    printf("%d\t", s); // 打印计算结果
    return s; // 返回计算结果
}

int main()
{
    fun(5); // 调用fun函数，参数为5
    printf("\n"); // 打印换行符
    return 0;
}

【代码详解】

1. 代码的功能是计算并打印一个递归序列

2. #include ：包含标准输入输出头文件。

3. long fun(int n)：函数 fun() 的定义，参数为整型 n。

4. long s;：声明长整型变量 s，用于存储计算结果。

5. if (n <= 2)：判断条件，如果 n 小于等于 2，则执行下一条语句。

6. s = 2;：当 n 小于等于 2 时，将 2 赋值给变量 s。

7. else：否则执行下一条语句。

8. s = n + fun(n - 1);：当 n 大于 2 时，将 n 加上对 fun 函数的递归调用结果 fun(n - 1) 赋值给变量 s。

9. printf("%d\t", s);：使用 printf 函数打印计算结果，"%d\t" 是格式化字符串，用于输出整数，并加上一个制表符。

10. return s;：返回计算结果 s。

11. int main()：主函数的定义。

12. fun(5);：调用 fun 函数，传入参数 5。

13. printf("\n");：打印一个换行符。

14. return 0;：返回 0，表示程序正常结束。

【计算过程】

1. fun(5)：在主函数中调用函数 fun()，传入参数 5。

2. fun(5) 执行：

   • n 的值为 5，不满足条件 n <= 2，执行 else 部分。
   • 计算 s = n + fun(n - 1)，即 s = 5 + fun(4)。

3. fun(4) 执行：

   • n 的值为 4，不满足条件 n <= 2，执行 else 部分。
   • 计算 s = n + fun(n - 1)，即 s = 4 + fun(3)。

4. fun(3) 执行：

   • n 的值为 3，不满足条件 n <= 2，执行 else 部分。
   • 计算 s = n + fun(n - 1)，即 s = 3 + fun(2)。

5. fun(2) 执行：

   • n 的值为2，满足条件 n <= 2，执行 if 部分。
   • 将 s 的值赋为 2。

6. 返回到上一层的 fun(3)，即 s = 3 + 2 = 5。

7. 返回到上一层的 fun(4)，即 s = 4 + 5 = 9。

8. 返回到上一层的 fun(5)，即 s = 5 + 9 = 14。

【执行结果】

 

  2       5       9       14

---

13. 遍历输出结构体数组中每个元素的姓名和年龄

#include 

// 定义结构体 porb
struct porb {
    const char* name;  // 姓名，使用指向常量的指针
    int age;           // 年龄
} s[] = {
    {"LiHua", 18},    // 第一个结构体元素，姓名为"LiHua"，年龄为18
    {"WangXin", 25},  // 第二个结构体元素，姓名为"WangXin"，年龄为25
    {"LiuGuo", 21}    // 第三个结构体元素，姓名为"LiuGuo"，年龄为21
};

// 定义宏 N，表示结构体数组 s 的大小
#define N (sizeof(s) / sizeof(s[0]))  // 定义常量N为结构体数组s的元素个数

// 函数声明
void f(struct porb A[], int n);

int main() {
    f(s, N);  // 调用函数 f，传入结构体数组 s 和常量 N
    return 0;
}

// 函数定义
void f(struct porb A[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        // 打印结构体数组中的 name 和 age 成员
        printf("%s:%d\n", A[i].name, A[i].age);  // 打印姓名和年龄
    }
}

【代码详解】

• 这段代码定义了一个 porb 结构体类型，包含了姓名和年龄两个成员。同时，创建了一个名为 s 的结构体数组，并初始化了其中的元素。
• 然后，使用宏定义指定常量N的值为结构体数组 s 的大小除以第一个元素 s[0] 的大小，以计算结构体数组的元素个数。
• 接下来，声明了函数 f() 的原型，并在 main() 函数中调用了函数 f()，传入结构体数组s 和常量 N 作为参数。
• 最后，定义了函数 f()，在该函数中使用循环遍历结构体数组，并使用 printf() 函数打印每个结构体元素的姓名和年龄。
• 该代码的功能是定义一个具有姓名和年龄属性的结构体类型，创建一个结构体数组 s，并在函数 f() 中遍历输出结构体数组中每个元素的姓名和年龄。主函数中调用了函数 f() 来执行这个功能。

【执行结果】

 

LiHua:18
WangXin:25
LiuGuo:21

---

14.  指向整型变量的指针和一个整数作为参数

#include 

// 定义函数 LE，接受一个指向整型变量的指针和一个整数作为参数
void LE(int* a, int b)
{
    int x = *a; // 将指针 a 指向位置的值赋给变量 x
    printf("%d\t%d\n", *a, b); // 打印指针 a 指向位置的值和变量 b 的值
    *a = b; // 将指针 a 指向位置的值更新为变量 b 的值
    b = x; // 将变量 b 的值更新为变量 x 的值
}

int main()
{
    int x = 10, y = 25; // 声明并初始化变量 x 和 y
    LE(&x, y); // 调用函数 LE，将变量 x 的地址和变量 y 的值作为参数传递
    printf("%d\t%d\n", x, y); // 打印变量 x 和变量 y 的值
    return 0;
}

【代码详解】

• 代码中定义了一个名为 LE 的函数，该函数接受一个指向整型变量的指针和一个整数作为参数。
• 函数内的操作如下：

1. int x = *a;：将指针 a 指向的位置的值赋给变量 x。

2. printf("%d\t%d\n", *a, b);：使用 printf 函数打印指针 a 指向的位置的值和变量 b 的值，并在两个值之间插入一个制表符和一个换行符。

3. *a = b;：将指针 a 指向位置的值更新为变量 b 的值。

4. b = x;：将变量 b 的值更新为变量 x 的值。

• 在 main 函数中：

1. int x = 10, y = 25;：声明并初始化变量 x 和 y。

2. LE(&x, y);：调用函数 LE，将变量 x 的地址和变量 y 的值作为参数传递。

3. printf("%d\t%d\n", x, y);：使用 printf 函数打印变量 x 和变量 y 的值，并在两个值之间插入一个制表符和一个换行符。

• 最后，main 函数返回 0，表示程序正常运行结束。

【执行结果】

 

10      25
25      25

---

15. 从键盘读取字符，并执行操作，打印字符结果

【题目】设从键盘输入：420 <回车> 

#include 

int main() {
    char c;

    // 从键盘输入一个字符，直到遇到换行符为止
    while ((c = getchar()) != '\n') {
        switch (c - '0') {
            case 0:
            case 1:
                putchar(c + 2); // 打印字符 c 加上 2
            case 2:
                putchar(c + 3); // 打印字符 c 加上 3
                break;
            case 3:
                putchar(c + 4); // 打印字符 c 加上 4
                break;
            default:
                putchar(c + 1); // 默认情况下，打印字符 c 加上 1
                break;
        }
    }

    printf("\n"); // 打印换行符
    return 0;
}

【代码详解】

1. 该代码的主要功能是从键盘读取字符，并根据字符的值执行不同的操作，然后打印相应的字符结果。

2. #include ：包含标准输入输出头文件。

3. int main()：主函数的定义。

4. char c;：声明字符型变量 c。

5. while ((c = getchar()) != '\n')：循环读取输入的字符，直到遇到换行符为止。每次循环将读取的字符赋值给变量 c。

6. switch (c - '0')：基于字符 c 减去字符 '0' 的差值，进行 switch 分支判断。

7. case 0: 和 case 1:：如果 c 是字符 '0' 或 '1'，则执行后续的代码。

8. putchar(c + 2);：打印字符 c 加上 2 的结果。

9. case 2:：如果 c 是字符 '2'，则执行后续的代码。

10. putchar(c + 3);：打印字符 c 加上 3 的结果。

11. break;：跳出 switch 语句。

12. case 3:：如果 c 是字符 '3'，则执行后续的代码。

13. putchar(c + 4);：打印字符 c 加上 4 的结果。

14. break;：跳出 switch 语句。

15. default:：默认情况下，如果以上的 case 都不匹配，则执行后续的代码。

16. putchar(c + 1);：打印字符 c 加上 1 的结果。

17. break;：跳出 switch 语句。

18. printf("\n");：打印一个换行符。

19. return 0;：返回 0，表示程序正常结束。

【执行结果】

• 假设键盘输入：420，则输出结果是：5523

• 在 while 循环中，getchar() 会从键盘读取一个字符，并将其赋值给变量 c，直到遇到换行符 ‘\n’ 结束。
• 在 switch 语句中，我们会根据输入的字符 c 进行不同的操作：
  • 如果 c - ‘0’ 的结果为 0 或 1，说明输入的字符是 ‘0’ 或 ‘1’，则执行以下操作：
    1. putchar(c + 2)：打印字符 c 加上 2 的结果。在输入的例子中，“420” 第 3位数字 ‘0’ ，即符合此条件，‘0’ + 2 = ‘2’，所以第 3 位数字会打印字符 ‘2’。
    2. 继续执行后面的代码，即 putchar(c + 3)：打印字符 c 加上 3 的结果。同样在输入的例子中，‘0’ + 3 = ‘3’，所以第 4 位数字会打印字符 ‘3’。
  • 如果 c - ‘0’ 的结果为 2，说明输入的字符是 ‘2’，则执行以下操作：
    1. putchar(c + 3)：打印字符 c 加上 3 的结果。在输入的例子中，“420” 第 2位数字 ‘2’ ，即符合此条件，‘2’ + 3 = ‘5’，所以第 2 位数字会打印字符 ‘5’。
    2. 执行 break，跳出 switch 语句。
  • 如果 c - ‘0’ 的结果为 3，说明输入的字符是 ‘3’，则执行以下操作：
    1. putchar(c + 4)：打印字符 c 加上 4 的结果。在输入的例子中，“420” 没有符合此条件的数字，所以跳过。
    2. 执行 break，跳出 switch 语句。
  • 如果以上情况都不满足（即默认情况），则执行以下操作：
    1. putchar(c + 1)：打印字符 c 加上 1 的结果。在输入的例子中，“420” 第 1位数字 ‘4’ ，即符合此条件，‘4’ + 1 = ‘5’，所以第 1 位数字会打印字符 ‘5’。
    2. 执行 break，跳出 switch 语句。

420
5523

---

16. 找出三位数中全部的水仙花数

【题目】一个三位整数 (100～999)，若各位数的立方和等于该数自身，则称其为 “水仙花数”(如：153=13+53+33 )，找出所有的这种数

#include 

int main() {
    int n, a, b, c; // n、a、b 和c 分别为三位数自身及其个位、十位和百位
    
    for (c = 1; c <= 9; c++) {
        for (b = 0; b <= 9; b++) {
            for (a = 0; a <= 9; a++) {
                n = c * 100 + b * 10 + a; // 将个位、十位和百位组成的数赋值给 n
                
                if (a * a * a + b * b * b + c * c * c == n) { // 若各位数的立方和等于该数自身
                    printf("%d\n", n); // 输出满足条件的水仙花数
                }
            }
        }
    }
    
    return 0;
}

【代码详解】

• 此段代码会生成并输出所有满足水仙花数条件的三位数。
• 代码中的三个嵌套循环用于遍历个位、十位和百位所有可能的数字（0 到 9），并构造三位数 n。
• 然后，代码会检查该三位数是否满足水仙花数条件：即各位数字的立方和等于该数自身。
• 满足条件的数将被输出。

【执行结果】

153
370
371
407

---

17.  输入数字返回英文单词

【题目】输入一个数字 (范围在 0～9 之间，若不在此范围内显示输入错)，输出对应的英文单词 (Zero, One,Two, ……,Nine)。

#include 

int main() {
    int i;
    const char* digit[10] = { "Zero", "One", "Two", "Three", "Four",
                             "Five", "Six", "Seven", "Eight", "Nine" };

    if (scanf_s("%d", &i) == 1) { // 使用 scanf_s 替换 scanf
        printf("%d→", i);
        if (i >= 0 && i <= 9) { // 检查输入是否在 0 到 9 之间
            printf("%s\n", digit[i]); // 打印对应数字的英文单词
        }
        else {
            printf("Input error! \n"); // 输入超出范围时打印错误信息
        }
    }
    else {
        printf("Input error! \n"); // 输入不是一个有效的整数时打印错误信息
    }

    return 0;
}

【代码详解】

1. 包含了  头文件，用于使用 C 标准输入输出函数。
2. 声明了一个变量 i，用于存储用户输入的整数。
3. 声明并初始化了一个字符串数组 digit，用于存储数字对应的英文单词。
4. 使用 scanf_s 函数从用户输入中读取一个整数，并将其赋值给变量 i。
5. 判断 scanf_s 返回的结果是否为 1，即是否成功读取了一个整数。
6. 如果成功读取整数，首先使用 printf 函数打印输入的整数，并在后面添加箭头符号 →。
7. 接着，判断输入的整数是否在 0 到 9 的范围之间。
8. 如果是，则使用 printf 函数打印对应数字的英文单词。
9. 如果不是，则打印错误信息 “Input error!”。
10. 如果输入不是一个有效的整数，也打印错误信息 “Input error!”。
11. 最后，返回整数 0，表示程序正常结束。

【执行结果】

• 键盘输入 “0~9” 整数时，输出对应数字的英文，如输入 “7”，则返回：Seven

7
7→Seven

• 键盘输入 非 “0~9” 整数时，则返回：Input error!

11
11→Input error!

---

18. 分科输入学生成绩计算总分、平均分

【题目】输入某学生的数学 (math)、英语 (english) 和 C 语言 (C) 的成绩，输出该学生这三门课的成绩、总成绩 (sum) 和平均成绩 (aver)。

#define _CRT_SECURE_NO_WARNINGS // 添加此宏定义以禁用 scanf 函数的警告

#include 

int main() {
    int math, english, c;
    int sum;
    float aver;

    // 输入三门课的成绩
    printf("请输入数学成绩: ");
    scanf_s("%d", &math);

    printf("请输入英语成绩: ");
    scanf_s("%d", &english);

    printf("请输入C语言成绩: ");
    scanf_s("%d", &c);

    // 计算总成绩和平均成绩
    sum = math + english + c;
    aver = (float)sum / 3;

    // 输出成绩信息
    printf("数学成绩: %d\n", math);
    printf("英语成绩: %d\n", english);
    printf("C语言成绩: %d\n", c);
    printf("总成绩: %d\n", sum);
    printf("平均成绩: %.2f\n", aver);

    return 0;
}

【代码详解】

• 这段代码实现了输入三门课的成绩，然后计算总成绩和平均成绩，并将所有成绩输出到控制台。

1. 定义了宏定义 _CRT_SECURE_NO_WARNINGS，用于禁用 scanf 函数的警告。
2. 引入  头文件，该头文件包含了输入输出相关的函数和定义。
3. 定义了 main 函数。
4. 声明了整型变量 math、english 和 c，用于存储输入的数学、英语和C语言成绩。
5. 声明了整型变量 sum，用于存储总成绩。
6. 声明了浮点型变量 aver，用于存储平均成绩。
7. 使用 printf 函数输出提示信息，要求用户输入数学成绩。
8. 使用 scanf_s 函数接收用户输入的数学成绩，并将其存储在 math 变量中。
9. 类似地，使用 printf 和 scanf_s 函数接收并存储英语和C语言成绩。
10. 计算总成绩，将数学、英语和C语言成绩相加，结果存储在 sum 变量中。
11. 计算平均成绩，将总成绩除以3，并将结果存储在 aver 变量中。
12. 使用 printf 函数输出数学、英语和C语言的成绩，总成绩和平均成绩。

【执行结果】

• 键盘分科输入整数成绩如下：

请输入数学成绩: 140
请输入英语成绩: 120
请输入C语言成绩: 92

• 执行结果：

请输入数学成绩: 140
请输入英语成绩: 120
请输入C语言成绩: 92
数学成绩: 140
英语成绩: 120
C语言成绩: 92
总成绩: 352
平均成绩: 117.33

---

19.  创建一个 5x5 的二维数组，并按照指定形式输出数组的元素

【题目】在一个二维数组 (定义为 int A［5］［5］;) 中形成并按下列形式输出矩阵各元素的值。

1  0  0  0  0

2  1  0  0  0

3  2  1  0  0

4  3  2  1  0

5  4  3  2  1

#include 

int main() {
    int A[5][5];

    // 初始化二维数组
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            // 如果当前列索引小于等于行索引，则设置对应元素的值为 i - j + 1
            if (j <= i) {
                A[i][j] = i - j + 1;
            }
            // 否则，将对应元素的值设置为 0
            else {
                A[i][j] = 0;
            }
        }
    }

    // 输出二维数组元素
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            // 使用 printf 函数输出数组元素，并在元素之间添加空格
            printf("%d ", A[i][j]);
        }
        // 在每行输出结束后，使用 printf 函数输出换行符
        printf("\n");
    }

    return 0;
}

【代码详解】

• 这段代码的功能是创建一个 5x5 的二维数组，并按照指定形式输出数组的元素。
• 这段代码的功能是创建并初始化一个特定形式的二维数组，然后按照该形式逐行输出数组的元素。

1. 首先，在 main 函数中定义了一个名为 A 的 5x5 的二维数组，用来存储数据。
2. 使用嵌套的循环对二维数组进行初始化。外层循环 i 控制行的索引，内层循环 j 控制列的索引。
3. 在循环内部使用条件判断语句 if (j <= i) 判断当前列索引是否小于等于行索引。若是，则将 i - j + 1 的值赋给数组元素 A[i][j]，从第一行开始，逐渐递减。否则，将对应元素的值设置为 0。
4. 最后，再次使用两个嵌套的循环遍历数组，通过 printf 函数将数组的元素逐个打印出来，并在元素之间添加空格。
5. 在每行的输出结束后，使用 printf("\n") 打印换行符，以换行到下一行的元素。

【执行结果】

1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1

---

20. 文件内容拷贝

【题目】将一个文本文件 (ma.dat) 拷贝到另一个文本文件 (niu.dat) 中

#define _CRT_SECURE_NO_WARNINGS  // 禁用警告
#include 

int main() {
    FILE* ma, * niu;
    ma = fopen_s("ma.dat", "r");    
    niu = fopen_s("niu.dat", "w");  
    while (!feof(ma))  // 循环，直到源文件的结尾
        fputc(fgetc(ma), niu);  // 从源文件读取一个字符，并将其写入目标文件
    fclose(niu);  // 关闭目标文件
    fclose(ma);   // 关闭源文件

    return 0;
}

【代码详解】

• 这段代码的功能是将一个文本文件（“ma.dat”）的内容复制到另一个文本文件（“niu.dat”）中。
• 代码的功能是打开源文件 “ma.dat”，以只读方式读取其中的内容，并将内容逐字符地写入目标文件 “niu.dat” 中。最后关闭文件并结束程序。

1. #define _CRT_SECURE_NO_WARNINGS：这是一个预处理指令，用于禁用警告。具体来说，_CRT_SECURE_NO_WARNINGS 禁用了关于 fopen_s 函数不安全的警告。

2. #include ：包含标准输入输出库的头文件。

3. int main()：定义主函数。

4. FILE* ma, * niu：声明两个文件指针 ma 和 niu。

5. ma = fopen_s("ma.dat", "r")：以只读方式打开源文件 “ma.dat”。fopen_s 是 fopen 的安全版本，在打开文件时需要传递文件指针的指针。

6. niu = fopen_s("niu.dat", "w")：以写入方式打开目标文件 “niu.dat”。同样使用 fopen_s 打开，并传递目标文件指针的指针。

7. while (!feof(ma))：循环，直到源文件的结尾。

8. fputc(fgetc(ma), niu)：从源文件读取一个字符，并将其写入目标文件。

9. fclose(niu)：关闭目标文件。

10. fclose(ma)：关闭源文件。

11. return 0：返回主函数的结束状态。