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

    目录

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

    12. 递归序列 

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

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

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

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

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

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

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

    20. 文件内容拷贝

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

    1. #include 
    2.  
    3. // 声明函数f的原型
    4. void f(int j);
    5.  
    6. // 主函数
    7. int main()
    8. {
    9.     int i;
    10.  
    11.     // 循环调用f函数两次
    12.     for (i = 1; i < 3; i++)
    13.     {
    14.         f(i);
    15.     }
    16. }
    17.  
    18. // f函数定义
    19. void f(int j)
    20. {
    21.     static int A = 100; // 静态变量A，初始值为100
    22.     int k = 1;         // 局部变量k，初始值为1
    23.  
    24.     ++k;               // 对k进行自增操作
    25.     printf("%d\n", j + A + k); // 打印j, A和k的和
    26.  
    27.     A -= 2;           // 对A进行减2操作
    28. }

    【代码详解】

    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。
    1. 103
    2. 102

    12. 递归序列 

    1. #include 
    2.  
    3. // 函数fun的定义
    4. long fun(int n)
    5. {
    6.     long s; // 存储计算结果
    7.  
    8.     if (n <= 2)
    9.         s = 2; // 当n小于等于2时，s的值为2
    10.     else
    11.         s = n + fun(n - 1); // 当n大于2时，s的值为n加上n-1的结果
    12.  
    13.     printf("%d\t", s); // 打印计算结果
    14.     return s; // 返回计算结果
    15. }
    16.  
    17. int main()
    18. {
    19.     fun(5); // 调用fun函数，参数为5
    20.     printf("\n"); // 打印换行符
    21.     return 0;
    22. }

    【代码详解】

    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. 遍历输出结构体数组中每个元素的姓名和年龄

    1. #include 
    2.  
    3. // 定义结构体 porb
    4. struct porb {
    5.     const char* name;  // 姓名，使用指向常量的指针
    6.     int age;           // 年龄
    7. } s[] = {
    8.     {"LiHua", 18},    // 第一个结构体元素，姓名为"LiHua"，年龄为18
    9.     {"WangXin", 25},  // 第二个结构体元素，姓名为"WangXin"，年龄为25
    10.     {"LiuGuo", 21}    // 第三个结构体元素，姓名为"LiuGuo"，年龄为21
    11. };
    12.  
    13. // 定义宏 N，表示结构体数组 s 的大小
    14. #define N (sizeof(s) / sizeof(s[0]))  // 定义常量N为结构体数组s的元素个数
    15.  
    16. // 函数声明
    17. void f(struct porb A[], int n);
    18.  
    19. int main() {
    20.     f(s, N);  // 调用函数 f，传入结构体数组 s 和常量 N
    21.     return 0;
    22. }
    23.  
    24. // 函数定义
    25. void f(struct porb A[], int n) {
    26.     int i;
    27.     for (i = 0; i < n; i++) {
    28.         // 打印结构体数组中的 name 和 age 成员
    29.         printf("%s:%d\n", A[i].name, A[i].age);  // 打印姓名和年龄
    30.     }
    31. }

    【代码详解】

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

    【执行结果】

     

    1. LiHua:18
    2. WangXin:25
    3. LiuGuo:21

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

    1. #include 
    2.  
    3. // 定义函数 LE，接受一个指向整型变量的指针和一个整数作为参数
    4. void LE(int* a, int b)
    5. {
    6.     int x = *a; // 将指针 a 指向位置的值赋给变量 x
    7.     printf("%d\t%d\n", *a, b); // 打印指针 a 指向位置的值和变量 b 的值
    8.     *a = b; // 将指针 a 指向位置的值更新为变量 b 的值
    9.     b = x; // 将变量 b 的值更新为变量 x 的值
    10. }
    11.  
    12. int main()
    13. {
    14.     int x = 10, y = 25; // 声明并初始化变量 x 和 y
    15.     LE(&x, y); // 调用函数 LE，将变量 x 的地址和变量 y 的值作为参数传递
    16.     printf("%d\t%d\n", x, y); // 打印变量 x 和变量 y 的值
    17.     return 0;
    18. }

    【代码详解】

    • 代码中定义了一个名为 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，表示程序正常运行结束。

    【执行结果】

     

    1. 10      25
    2. 25      25

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

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

    1. #include 
    2.  
    3. int main() {
    4.     char c;
    5.  
    6.     // 从键盘输入一个字符，直到遇到换行符为止
    7.     while ((c = getchar()) != '\n') {
    8.         switch (c - '0') {
    9.             case 0:
    10.             case 1:
    11.                 putchar(c + 2); // 打印字符 c 加上 2
    12.             case 2:
    13.                 putchar(c + 3); // 打印字符 c 加上 3
    14.                 break;
    15.             case 3:
    16.                 putchar(c + 4); // 打印字符 c 加上 4
    17.                 break;
    18.             default:
    19.                 putchar(c + 1); // 默认情况下，打印字符 c 加上 1
    20.                 break;
    21.         }
    22.     }
    23.  
    24.     printf("\n"); // 打印换行符
    25.     return 0;
    26. }

    【代码详解】

    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 语句。
    1. 420
    2. 5523

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

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

    1. #include 
    2.  
    3. int main() {
    4.     int n, a, b, c; // n、a、b 和c 分别为三位数自身及其个位、十位和百位
    5.     
    6.     for (c = 1; c <= 9; c++) {
    7.         for (b = 0; b <= 9; b++) {
    8.             for (a = 0; a <= 9; a++) {
    9.                 n = c * 100 + b * 10 + a; // 将个位、十位和百位组成的数赋值给 n
    10.                 
    11.                 if (a * a * a + b * b * b + c * c * c == n) { // 若各位数的立方和等于该数自身
    12.                     printf("%d\n", n); // 输出满足条件的水仙花数
    13.                 }
    14.             }
    15.         }
    16.     }
    17.     
    18.     return 0;
    19. }

    【代码详解】

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

    【执行结果】

    1. 153
    2. 370
    3. 371
    4. 407

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

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

    1. #include 
    2.  
    3. int main() {
    4.     int i;
    5.     const char* digit[10] = { "Zero", "One", "Two", "Three", "Four",
    6.                              "Five", "Six", "Seven", "Eight", "Nine" };
    7.  
    8.     if (scanf_s("%d", &i) == 1) { // 使用 scanf_s 替换 scanf
    9.         printf("%d→", i);
    10.         if (i >= 0 && i <= 9) { // 检查输入是否在 0 到 9 之间
    11.             printf("%s\n", digit[i]); // 打印对应数字的英文单词
    12.         }
    13.         else {
    14.             printf("Input error! \n"); // 输入超出范围时打印错误信息
    15.         }
    16.     }
    17.     else {
    18.         printf("Input error! \n"); // 输入不是一个有效的整数时打印错误信息
    19.     }
    20.  
    21.     return 0;
    22. }

    【代码详解】

    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
    1. 7
    2. 7→Seven
    • 键盘输入 非 “0~9” 整数时，则返回：Input error!
    1. 11
    2. 11→Input error!

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

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

    1. #define _CRT_SECURE_NO_WARNINGS // 添加此宏定义以禁用 scanf 函数的警告
    2.  
    3. #include 
    4.  
    5. int main() {
    6.     int math, english, c;
    7.     int sum;
    8.     float aver;
    9.  
    10.     // 输入三门课的成绩
    11.     printf("请输入数学成绩: ");
    12.     scanf_s("%d", &math);
    13.  
    14.     printf("请输入英语成绩: ");
    15.     scanf_s("%d", &english);
    16.  
    17.     printf("请输入C语言成绩: ");
    18.     scanf_s("%d", &c);
    19.  
    20.     // 计算总成绩和平均成绩
    21.     sum = math + english + c;
    22.     aver = (float)sum / 3;
    23.  
    24.     // 输出成绩信息
    25.     printf("数学成绩: %d\n", math);
    26.     printf("英语成绩: %d\n", english);
    27.     printf("C语言成绩: %d\n", c);
    28.     printf("总成绩: %d\n", sum);
    29.     printf("平均成绩: %.2f\n", aver);
    30.  
    31.     return 0;
    32. }

    【代码详解】

    • 这段代码实现了输入三门课的成绩，然后计算总成绩和平均成绩，并将所有成绩输出到控制台。
    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语言的成绩，总成绩和平均成绩。

    【执行结果】

    • 键盘分科输入整数成绩如下：
    1. 请输入数学成绩: 140
    2. 请输入英语成绩: 120
    3. 请输入C语言成绩: 92
    • 执行结果：
    1. 请输入数学成绩: 140
    2. 请输入英语成绩: 120
    3. 请输入C语言成绩: 92
    4. 数学成绩: 140
    5. 英语成绩: 120
    6. C语言成绩: 92
    7. 总成绩: 352
    8. 平均成绩: 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

    1. #include 
    2.  
    3. int main() {
    4.     int A[5][5];
    5.  
    6.     // 初始化二维数组
    7.     for (int i = 0; i < 5; i++) {
    8.         for (int j = 0; j < 5; j++) {
    9.             // 如果当前列索引小于等于行索引，则设置对应元素的值为 i - j + 1
    10.             if (j <= i) {
    11.                 A[i][j] = i - j + 1;
    12.             }
    13.             // 否则，将对应元素的值设置为 0
    14.             else {
    15.                 A[i][j] = 0;
    16.             }
    17.         }
    18.     }
    19.  
    20.     // 输出二维数组元素
    21.     for (int i = 0; i < 5; i++) {
    22.         for (int j = 0; j < 5; j++) {
    23.             // 使用 printf 函数输出数组元素，并在元素之间添加空格
    24.             printf("%d ", A[i][j]);
    25.         }
    26.         // 在每行输出结束后，使用 printf 函数输出换行符
    27.         printf("\n");
    28.     }
    29.  
    30.     return 0;
    31. }

    【代码详解】

    • 这段代码的功能是创建一个 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. 1 0 0 0 0
    2. 2 1 0 0 0
    3. 3 2 1 0 0
    4. 4 3 2 1 0
    5. 5 4 3 2 1

    20. 文件内容拷贝

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

    1. #define _CRT_SECURE_NO_WARNINGS  // 禁用警告
    2. #include 
    3.  
    4. int main() {
    5.     FILE* ma, * niu;
    6.     ma = fopen_s("ma.dat", "r");    
    7.     niu = fopen_s("niu.dat", "w");  
    8.     while (!feof(ma))  // 循环，直到源文件的结尾
    9.         fputc(fgetc(ma), niu);  // 从源文件读取一个字符，并将其写入目标文件
    10.     fclose(niu);  // 关闭目标文件
    11.     fclose(ma);   // 关闭源文件
    12.  
    13.     return 0;
    14. }

    【代码详解】

    • 这段代码的功能是将一个文本文件（“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：返回主函数的结束状态。

  • 相关阅读:
    Makefile中的变量
    前端食堂技术周刊第 47 期：Docusaurus 2.0 、7 月登陆网络平台的新内容 、Nuxt.js 团队的轮子库
    Android开发对压缩文件的处理
    c语言入门---预处理
    web渗透测试----5、暴力破解漏洞--（1）SSH密码破解
    selenium的各种操作
    微信小程序获取微信用户步数
    智慧城市建设方案建议书——如何打造智慧城市
    matlab第三方硬件支持包下载和安装
    mysql请求阻塞
  • 原文地址：https://blog.csdn.net/qq_39720249/article/details/132135074