C语言04函数与递归

最新推荐文章于 2023-11-17 14:34:46 发布
最新推荐文章于 2023-11-17 14:34:46 发布
阅读量1k 收藏 3
点赞数
分类专栏： C语言 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/opera95/article/details/51200820
版权


1 函数的定义

1.1 问题

自定义两个简单的函数，使用return返回数据。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：函数的定义

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int getInt()
  4. {
  5.     return 10;
  6. }
  8. double getDouble()
  9. {
  10.     return 5.5;
  11. }
  13. int main()
  14. {
  15.     int n;
  16.     n = getInt();
  17.     printf ("%d\n", n);
  19.     double d;
  20.     d = getDouble();
  21.     printf("%lf\n", d);
  23.     return 0;
  24. }

上述代码中，以下代码：


    
    
  1. int getInt()
  2. {
  3.     return 10;
  4. }

定义了一个函数getInt，该函数返回一个整型数据，没有参数。

上述代码中，以下代码：


    
    
  1. double getDouble()
  2. {
  3.     return 5.5;
  4. }

定义了一个函数getDouble，该函数返回一个双精度浮点型数据，没有参数。

上述代码中，以下代码：


    
    
  1.     int n;
  2.     n = getInt();
  3.     printf ("%d\n", n);

首先，定义一个整型变量n，用于存储getInt函数的返回值。

然后，调用函数getInt得到返回值，并存储在变量n中。

最后，使用函数printf输出变量n的内容。

上述代码中，以下代码：


    
    
  1.     double d;
  2.     d = getDouble();
  3.     printf("%lf\n", d);

首先，定义一个双精度浮点型变量d，用于存储getDouble函数的返回值。

然后，调用函数getDouble得到返回值，并存储在变量d中。

最后，使用函数printf输出变量d的内容。

1.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int getInt()
  4. {
  5.     return 10;
  6. }
  8. double getDouble()
  9. {
  10.     return 5.5;
  11. }
  13. int main()
  14. {
  15.     int n;
  16.     n = getInt();
  17.     printf ("%d\n", n);
  19.     double d;
  20.     d = getDouble();
  21.     printf("%lf\n", d);
  23.     return 0;
  24. }

2 函数的声明

2.1 问题

定义两个函数，分别测试隐式声明和显式声明，同时体现出隐式声明中类型的自动提示效果。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：函数的声明

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     f1();
  6.     double f2(/*void*//*int i*/);
  7.     f2(1,2);
  8.     return 0;
  9. }
  11. int f1()
  12. {
  13.     printf("f1()\n");
  14.     return 0;
  15. }
  17. double f2(int a,int b)
  18. {
  19.     printf("f2()\n");
  20.     return 3.0;
  21. }

上述代码中，以下代码：


    
    
  1.     f1();

由于在调用f1前未对其进行声明，所以是隐式声明。

上述代码中，以下代码：


    
    
  1.     double f2(/*void*//*int i*/);

对函数f2进行显示声明。其中，参数可以省略。如果没有任何参数，表示可以接受任意的参数，如果写void表示不接受任何参数。

上述代码中，以下代码：


    
    
  1.     f2(1,2);

调用函数f2。

上述代码中，以下代码：


    
    
  1. int f1()
  2. {
  3.     printf("f1()\n");
  4.     return 0;
  5. }

定义了一个函数f1。该函数没有参数，返回一个整型数据。

上述代码中，以下代码：


    
    
  1. double f2(int a,int b)
  2. {
  3.     printf("f2()\n");
  4.     return 3.0;
  5. }

定义了一个函数f2。该函数有两个参数，分别是整型变量a和b。在函数体中并没有使用这两个参数，这是允许的。

2.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     f1();
  6.     double f2(/*void*//*int i*/);
  7.     f2(1,2);
  8.     return 0;
  9. }
  11. int f1()
  12. {
  13.     printf("f1()\n");
  14.     return 0;
  15. }
  17. double f2(int a,int b)
  18. {
  19.     printf("f2()\n");
  20.     return 3.0;
  21. }

3 函数参数的应用

3.1 问题

定义两个函数，分别体现参数传递时的值传递和数组做参数时的处理方法。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：函数参数的应用

代码如下所示：


    
    
  1. #include <stdio.h>
  3. void fun1(int a)
  4. {
  5.     printf("形参a从主函数传入fun1时的值为%d\n", a);
  6.     a = a + 10;
  7.     printf("形参a在fun1中改变后的值为%d\n", a);
  8. }
  10. void fun2(int array[])
  11. {
  12.     printf("形参array[0]从主函数传入fun2时的值为%d\n", array[0]);
  13.     array[0] = array[0] + 10;
  14.     printf("形参array[0]在fun2中改变后的值为%d\n", array[0]);
  15. }
  17. int main()
  18. {
  19.     int a = 5;
  20.     int array[10] = {1};
  22.     printf("变量a在调用函数fun1之前的值为%d\n", a);
  23.     fun1(a);
  24.     printf("变量a在调用函数fun1之后的值为%d\n", a);
  26.     printf("\n");
  27.     printf("数组元素a[0]在调用函数fun2之前的值为%d\n", array[0]);
  28.     fun2(array);
  29.     printf("数组元素a[0]在调用函数fun2之后的值为%d\n", array[0]);
  31.     return 0;
  32. }

上述代码中，以下代码：


    
    
  1. void fun1(int a)
  2. {
  3.     printf("形参a从主函数传入fun1时的值为%d\n", a);
  4.     a = a + 10;
  5.     printf("形参a在fun1中改变后的值为%d\n", a);
  6. }

首先，定义了一个函数fun1，该函数有一个参数，为整型变量a。

然后，使用函数printf输出形参a从调用函数传入的值。

下一步，将形参a加上10。

最后，再使用函数printf输出形参a加上10后的值。两次调用可以看出形参a的变化情况。

上述代码中，以下代码：


    
    
  1. void fun2(int array[])
  2. {
  3.     printf("形参array[0]从主函数传入fun2时的值为%d\n", array[0]);
  4.     array[0] = array[0] + 10;
  5.     printf("形参array[0]在fun2中改变后的值为%d\n", array[0]);
  6. }

首先，定义了一个函数fun1，该函数有一个参数，为整型数组array。

然后，使用函数printf输出形参数组的第一个元素array[0]从调用函数传入的值。

下一步，将形参数组的第一个元素array[0]加上10。

最后，再使用函数printf输出形参数组的第一个元素array[0]加上10后的值。两次调用可以看出形参数组的第一个元素array[0]的变化情况。

上述代码中，以下代码：


    
    
  1. int main()
  2. {
  3.     int a = 5;
  4.     int array[10] = {1};

在主函数中定义一个整型变量a和一个整型数组array，并将变量a初始化为5，将数组array的第一个元素初始化成1。

上述代码中，以下代码：


    
    
  1.     printf("变量a在调用函数fun1之前的值为%d\n", a);
  2.     fun1(a);
  3.     printf("变量a在调用函数fun1之后的值为%d\n", a);

首先，使用函数printf输出变量a在调用函数fun1之前的值。

然后，调用函数fun1。

最后，再使用函数printf输出变量a在调用函数fun1之后的值。两次调用可以看出变量a的变化情况。

上述代码中，以下代码：


    
    
  1.     printf("数组元素a[0]在调用函数fun2之前的值为%d\n", array[0]);
  2.     fun2(array);
  3.     printf("数组元素a[0]在调用函数fun2之后的值为%d\n", array[0]);

首先，使用函数printf输出整型数组array的第一个元素array[0]在调用函数fun2之前的值。

然后，调用函数fun2。

最后，再使用函数printf输出整型数组array的第一个元素array[0]在调用函数fun2之后的值。两次调用可以看出整型数组array的第一个元素array[0]的变化情况。

3.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. void fun1(int a)
  4. {
  5.     printf("形参a从主函数传入fun1时的值为%d\n", a);
  6.     a = a + 10;
  7.     printf("形参a在fun1中改变后的值为%d\n", a);
  8. }
  10. void fun2(int array[])
  11. {
  12.     printf("形参array[0]从主函数传入fun2时的值为%d\n", array[0]);
  13.     array[0] = array[0] + 10;
  14.     printf("形参array[0]在fun2中改变后的值为%d\n", array[0]);
  15. }
  17. int main()
  18. {
  19.     int a = 5;
  20.     int array[10] = {1};
  22.     printf("变量a在调用函数fun1之前的值为%d\n", a);
  23.     fun1(a);
  24.     printf("变量a在调用函数fun1之后的值为%d\n", a);
  26.     printf("\n");
  27.     printf("数组元素a[0]在调用函数fun2之前的值为%d\n", array[0]);
  28.     fun2(array);
  29.     printf("数组元素a[0]在调用函数fun2之后的值为%d\n", array[0]);
  31.     return 0;
  32. }

4 函数和程序的终止

4.1 问题

定义一个函数，分别调用return语句和exit()函数，并在主函数中调用测试效果。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：函数和程序的终止

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. void fun(int e)
  5. {
  6.     if (1 == e)
  7.         exit(EXIT_SUCCESS);
  8.     else
  9.         return;
  10. }
  12. int main()
  13. {
  14.     int n;
  15.     printf("输入1在函数fun中调用exit函数\n输入2函数fun中执行return语句\n请选择输入：");
  16.     scanf("%d", &n);
  18.     fun(n);
  20.     printf("选择2才会输出此句");
  22.     return 0;
  23. }

上述代码中，以下代码：


    
    
  1. void fun(int e)
  2. {
  3.     if (1 == e)
  4.         exit(EXIT_SUCCESS);
  5.     else
  6.         return;
  7. }

定义了一个函数，该函数有一个参数为整型变量e。当参数e为1时，函数fun将调用函数exit退出程序；当参数e为其它值时，函数fun执行return语句返回。

上述代码中，以下代码：


    
    
  1.     int n;
  2.     printf("输入1在函数fun中调用exit函数\n输入2函数fun中执行return语句\n请选择输入：");
  3.     scanf("%d", &n);

首先，定义一个整型变量n，用于存储用户输入的选择。

然后，使用函数printf提示输入选择。

最后，使用函数scanf输入一个选择到变量n中。

上述代码中，以下代码：


    
    
  1.     fun(n);

将用户的选择，变量n，作为实参调用函数fun。

上述代码中，以下代码：


    
    
  1.     printf("选择2才会输出此句");

当用户选择1时，程序会在函数fun中退出，则此语句将不被执行。只有用户选择了2或其他值时，函数fun将执行return语句返回，此语句才被执行。

4.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. void fun(int e)
  5. {
  6.     if (1 == e)
  7.         exit(EXIT_SUCCESS);
  8.     else
  9.         return;
  10. }
  12. int main()
  13. {
  14.     int n;
  15.     printf("输入1在函数fun中调用exit函数\n输入2函数fun中执行return语句\n请选择输入：");
  16.     scanf("%d", &n);
  18.     fun(n);
  20.     printf("选择2才会输出此句\n");
  22.     return 0;
  23. }

5 递归和递推的应用

5.1 问题

分别使用递归函数和循环递推的方式实现n的阶乘。

5.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：递归和递推的应用。

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int factorial(int n)
  4. {
  5.     if (1 == n)
  6.         return 1;
  7.     int f;
  8.     f = n * factorial(n - 1);
  10.     return f;
  11. }
  13. int main()
  14. {
  15.     int n;
  16.     printf("请输入求阶乘的数：");
  17.     scanf("%d", &n);
  19.     int f = 1;
  20.     for (int i = 2; i <= n; i++)
  21.         f *= i;
  22.     printf("递推方法求得%d的阶乘为%d\n", n, f);
  24.     f = factorial(n);
  25.     printf("递归方法求得%d的阶乘为%d\n", n, f);
  27.     return 0;
  28. }

上述代码中,以下代码：


    
    
  1. int factorial(int n)
  2. {
  3.     if (1 == n)
  4.         return 1;
  5.     int f;
  6.     f = n * factorial(n - 1);
  8.     return f;
  9. }

定义递归函数factorial，用于计算整数n的阶乘。在该函数中，以下语句：


    
    
  1.     if (1 == n)
  2.         return 1;

为递归函数的出口，因为1的阶乘还是1。在该函数中，以下语句：


    
    
  1.     int f;
  2.     f = n * factorial(n - 1);

如果求整数n的阶乘，则转化为求n乘以n–1的阶乘，而n–1的阶乘的计算方法还是调用factorial函数，只是参数变成n-1。

上述代码中,以下代码：


    
    
  1. int main()
  2. {
  3.     int n;
  4.     printf("请输入求阶乘的数：");
  5.     scanf("%d", &n);

首先，定义一个整型变量n，用于存储求阶乘的数。

然后，使用函数printf提示输入求阶乘的数。

最后，使用函数scanf输入求阶乘的数到变量n中。

上述代码中,以下代码：


    
    
  1.     int f = 1;
  2.     for (int i = 2; i <= n; i++)
  3.         f *= i;
  4.     printf("递推方法求得%d的阶乘为%d\n", n, f);

是使用递推的方法求整数n的阶乘，n的阶乘是计算方法为1x2x3x· · ·xN，所以使用循环逐次相乘，得到整数n的阶乘。

上述代码中,以下代码：


    
    
  1.     f = factorial(n);
  2.     printf("递归方法求得%d的阶乘为%d\n", n, f);

是使用递归的方法求整数n的阶乘，调用函数factorial，得到整数n的阶乘。

5.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int factorial(int n)
  4. {
  5.     if (1 == n)
  6.         return 1;
  7.     int f;
  8.     f = n * factorial(n - 1);
  10.     return f;
  11. }
  13. int main()
  14. {
  15.     int n;
  16.     printf("请输入求阶乘的数：");
  17.     scanf("%d", &n);
  19.     int f = 1;
  20.     for (int i = 2; i <= n; i++)
  21.         f *= i;
  22.     printf("递推方法求得%d的阶乘为%d\n", n, f);
  24.     f = factorial(n);
  25.     printf("递归方法求得%d的阶乘为%d\n", n, f);
  27.     return 0;
  28. }

6 递归和递推的比较

6.1 问题

定义两个函数，分别用递归和递推方式计算费氏数列的第n项，并利用time命令查看时间差。

6.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：递归和递推的应用。

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  4. long fib(int n)
  5. {
  6.     long f1 = 1;
  7.     long f2 = 1;
  8.     long fn = 1;
  10.     for (int i = 2; i < n; i++)
  11.     {
  12.         fn = f1 + f2;
  13.         f1 = f2;
  14.         f2 = fn;
  15.     }
  17.     return fn;
  18. }
  20. long fib_f(int n)
  21. {
  22.     if (1 == n || 2 == n)
  23.         return 1;
  25.     return fib_f(n - 1) + fib_f(n - 2);
  26. }
  28. int main()
  29. {
  30.     int n;
  31.     printf("请输入月份：");
  32.     scanf("%d", &n);
  34.     time_t begin = time(0);
  35.     long sum = fib(n);
  36.     time_t stop = time(0);
  37.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));
  39.     begin = time(0);
  40.     sum = fib_f(n);
  41.     stop = time(0);
  42.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));
  44.     return 0;
  45. }

上述代码中，以下代码：


    
    
  1. long fib(int n)
  2. {
  3.     long f1 = 1;
  4.     long f2 = 1;
  5.     long fn = 1;
  7.     for (int i = 2; i < n; i++)
  8.     {
  9.         fn = f1 + f2;
  10.         f1 = f2;
  11.         f2 = fn;
  12.     }
  14.     return fn;
  15. }

定义了一个使用递推的方法求费氏数列的函数fib，该函数有一个参数是要求第几个月的兔子数。费氏数列的计算公式为:

f1 = 1

f2 = 1

fn = fn-1 + fn-2

上述代码中，以下代码：


    
    
  1.         fn = f1 + f2;

按计算公式fn = fn-1 + fn-2计算。

上述代码中，以下代码：


    
    
  1.         f1 = f2;
  2.         f2 = fn;

为下一次循环中公式fn = fn-1 + fn-2中的f1和f2做准备。

上述代码中，以下代码：


    
    
  1. long fib_f(int n)
  2. {
  3.     if (1 == n || 2 == n)
  4.         return 1;
  6.     return fib_f(n - 1) + fib_f(n - 2);
  7. }

定义了一个使用递归的方法求费氏数列的函数fib_f，该函数有一个参数是要求第几个月的兔子数。该函数中，以下代码:


    
    
  1.     if (1 == n || 2 == n)
  2.         return 1;

为递归出口，根据公式，第1个月和第2个月的兔子数均为1。该函数中，以下代码:


    
    
  1.     return fib_f(n - 1) + fib_f(n - 2);

根据公式fn = fn-1 + fn-2求第n个月的兔子数，因为求第n-1个月和第n-2个月与求第n个月的兔子数方法相同，都是调用fib_f函数，只是参数不同罢了，所以使用递归方法。

上述代码中，以下代码：


    
    
  1. int main()
  2. {
  3.     int n;
  4.     printf("请输入月份：");
  5.     scanf("%d", &n);

首先，定义一个整型变量n，用于存储求兔子数的月份数。

然后，使用函数printf提示输入求兔子数的月份数。

最后，使用函数scanf输入求兔子数的月份数到变量n中。

上述代码中，以下代码：


    
    
  1.     time_t begin = time(0);
  2.     long sum = fib(n);
  3.     time_t stop = time(0);
  4.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));

首先，使用time函数记录调用递推方法函数fib开始的时间。

然后，调用函数fib计算输入月份的兔子数。

下一步，使用time函数记录调用递推方法函数fib结束的时间。

最后，打印输入月份的兔子数和计算所用的时间数。

上述代码中，以下代码：


    
    
  1.     begin = time(0);
  2.     sum = fib_f(n);
  3.     stop = time(0);
  4.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));

首先，使用time函数记录调用递归方法函数fib_f开始的时间。

然后，调用函数fib_f计算输入月份的兔子数。

下一步，使用time函数记录调用递归方法函数fib_f结束的时间。

最后，打印输入月份的兔子数和计算所用的时间数。

6.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  4. long fib(int n)
  5. {
  6.     long f1 = 1;
  7.     long f2 = 1;
  8.     long fn = 1;
  10.     for (int i = 2; i < n; i++)
  11.     {
  12.         fn = f1 + f2;
  13.         f1 = f2;
  14.         f2 = fn;
  15.     }
  17.     return fn;
  18. }
  20. long fib_f(int n)
  21. {
  22.     if (1 == n || 2 == n)
  23.         return 1;
  25.     return fib_f(n - 1) + fib_f(n - 2);
  26. }
  28. int main()
  29. {
  30.     int n;
  31.     printf("请输入月份：");
  32.     scanf("%d", &n);
  34.     time_t begin = time(0);
  35.     long sum = fib(n);
  36.     time_t stop = time(0);
  37.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));
  39.     begin = time(0);
  40.     sum = fib_f(n);
  41.     stop = time(0);
  42.     printf("费氏数列第%d月兔子数为%ld，递推方法用时%lf秒\n", n, sum, difftime(stop, begin));
  44.     return 0;
  45. }

7 递归的典型应用

7.1 问题

使用递归实现汉诺塔。

汉诺塔是指法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片：一次只移动一片，不管在哪根针上，小片必须在大片上面。僧侣们预言，当所有的金片都从梵天穿好的那根针上移到另外一根针上时，世界就将在一声霹雳中消灭，而梵塔、庙宇和众生也都将同归于尽。

7.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：递归的典型应用。

代码如下所示：


    
    
  1. #include <stdio.h>
  3. void move(int n,char a,char b,char c)
  4. {
  5.     if(n==1)
  6.         printf("\t%c->%c\n",a,c);    
  7.     else
  8.     {
  9.         move(n-1,a,c,b);            
  10.         printf("\t%c->%c\n",a,c);
  11.         move(n-1,b,a,c);            
  12.     }
  13. }
  15. int main()
  16. {
  17.     int n;
  18.     printf("请输入要移动的块数：");
  19.     scanf("%d",&n);
  20.     
  21.     move(n,'a','b','c');
  22.     
  23.     return 0;
  24. }

上述代码中，以下代码：


    
    
  1. void move(int n,char a,char b,char c)
  2. {
  3.     if(n==1)
  4.         printf("\t%c->%c\n",a,c);    
  5.     else
  6.     {
  7.         move(n-1,a,c,b);            
  8.         printf("\t%c->%c\n",a,c);
  9.         move(n-1,b,a,c);            
  10.     }
  11. }

定义了一个递归函数move，用来模拟移动盘子。该函数有四个参数，说明如下：

第一个参数为盘子的数量。

第二个参数为从这根针移走。

第三个参数为经过这根针。

第四个参数为移到这根针。

在该函数中，以下代码：


    
    
  1.     if(n==1)
  2.         printf("\t%c->%c\n",a,c);

表示当n只有1个盘子的时候直接从a移动到c。

在该函数中，以下代码：


    
    
  1.         move(n-1,a,c,b);

表示第n-1个盘子要从a通过c移动到b。

在该函数中，以下代码：


    
    
  1.         printf("\t%c->%c\n",a,c);

输出从a移动到c。

在该函数中，以下代码：


    
    
  1.         move(n-1,b,a,c);

表示n-1个盘子移动到b后，b变开始盘，b通过a移动到c。

上述代码中，以下代码：


    
    
  1. int main()
  2. {
  3.     int n;
  4.     printf("请输入要移动的块数：");
  5.     scanf("%d",&n);

首先，定义一个整型变量n，用于存储要移动的盘子数。

然后，使用函数printf提示输入要移动的盘子数。

最后，使用函数scanf输入要移动的盘子数到变量n中。

上述代码中，以下代码：


    
    
  1.     move(n,'a','b','c');

启动移动函数，输出移动过程。

7.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. void move(int n,char a,char b,char c)
  4. {
  5.     if(n==1)
  6.         printf("\t%c->%c\n",a,c);    //当n只有1个的时候直接从a移动到c
  7.     else
  8.     {
  9.         move(n-1,a,c,b);            //第n-1个要从a通过c移动到b
  10.         printf("\t%c->%c\n",a,c);
  11.         move(n-1,b,a,c);            //n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解
  12.     }
  13. }
  15. int main()
  16. {
  17.     int n;
  18.     printf("请输入要移动的块数：");
  19.     scanf("%d",&n);
  20.     
  21.     move(n,'a','b','c');
  22.     
  23.     return 0;
  24. }

标准函数库

1 格式化输入输出

1.1 问题

测试格式化输入输出函数的中格式字符串的各种效果。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：格式化输入输出

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a = 0, b = 0;
  6.     scanf("%*d%d", &a, &b);
  7.     printf("a = %d, b = %d\n", a, b);
  8.     
  9.     printf("%10d,%-10d,%d\n", 100, 200, 300);
  10.     printf("%08d\n", 100);
  11.     printf("%0*d\n", 8, 100);
  12.     printf("0%o,0x%x\n", 8, 16);
  13.     
  14.     printf("%.2f\n", 12.34567);
  15.     printf("%10.2f\n", 12.34567);
  17.     return 0;
  18. }

上述代码中，以下代码：


    
    
  1.     scanf("%*d%d", &a, &b);

%*d中的*表示禁止字符，即输入的第一个数据被跳过，不进行赋值。

上述代码中，以下代码：


    
    
  1.     printf("%10d,%-10d,%d\n", 100, 200, 300);

首先，%10d中的10表示该数据如果不足10位则左边补空格。

然后，%-10d中的-10表示该数据如果不足10位则右边补空格。

上述代码中，以下代码：


    
    
  1.     printf("%08d\n", 100);

%08d中的08表示数据如果不足8位则左边补0。

上述代码中，以下代码：


    
    
  1.     printf("%0*d\n", 8, 100);

%0*d中的0*表示数据不足后面第一个参数，即8，所含的位数，则左边补0。

上述代码中，以下代码：


    
    
  1.     printf("0%o,0x%x\n", 8, 16);

0%o表示将数据按8进制输出；0x%x表示将数据按16进制输出。

上述代码中，以下代码：


    
    
  1.     printf("%.2f\n", 12.34567);

%.2f表示将数据保留2位小数。

上述代码中，以下代码：


    
    
  1.     printf("%10.2f\n", 12.34567);

%10.2表示将数据保留2位小数，且包括小数点在内的位数不足10位时，左边补0。

1.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main()
  4. {
  5.     int a = 0, b = 0;
  6.     scanf("%*d%d", &a, &b);
  7.     printf("a = %d, b = %d\n", a, b);
  8.     
  9.     printf("%10d,%-10d,%d\n", 100, 200, 300);
  10.     printf("%08d\n", 100);
  11.     printf("%0*d\n", 8, 100);
  12.     printf("0%o,0x%x\n", 8, 16);
  13.     
  14.     printf("%.2f\n", 12.34567);
  15.     printf("%10.2f\n", 12.34567);
  17.     return 0;
  18. }

2 动态分配内存

2.1 问题

动态分配基本类型和字符串的内存，并进行数据存储和取出打印。(最后记得用free()释放)

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：动态分配内存

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7.     int *pi = (int*)malloc(sizeof(int));
  8.     *pi = 10;
  9.     printf("*pi = %d\n", *pi);
  10.     free(pi);
  11.     
  12.     float *pf = (float*)malloc(sizeof(float));
  13.     *pf = 10.23;
  14.     printf("*pf = %f\n", *pf);
  15.     free(pf);
  16.     
  17.     double *pd = (double*)malloc(sizeof(double));
  18.     *pd = 123.456;
  19.     printf("*pd = %lf\n", *pd);
  20.     free(pd);
  21.     
  22.     char *pstr = (char*)malloc(1024);
  23.     strcpy(pstr, "将字符串放在堆上");
  24.     printf("%s\n", pstr);
  25.     free(pstr);
  26.     
  27.     return 0;
  28. }

上述代码中，以下代码：


    
    
  1.     int *pi = (int*)malloc(sizeof(int));

在堆上动态分配一个整型变量。

上述代码中，以下代码：


    
    
  1.     *pi = 10;

将动态分配的整型变量赋值。

上述代码中，以下代码：


    
    
  1.     printf("*pi = %d\n", *pi);

使用printf函数输出动态变量的值。

上述代码中，以下代码：


    
    
  1.     free(pi);

释放动态变量所占的存储空间。

上述代码中，以下代码：


    
    
  1.     float *pf = (float*)malloc(sizeof(float));

在堆上动态分配一个单精度浮点型变量。

上述代码中，以下代码：


    
    
  1.     *pf = 10.23;

将动态分配的单精度浮点型变量赋值。

上述代码中，以下代码：


    
    
  1.     printf("*pf = %f\n", *pf);

使用printf函数输出动态变量的值。

上述代码中，以下代码：


    
    
  1.     free(pf);

释放动态变量所占的存储空间。

上述代码中，以下代码：


    
    
  1.     double *pd = (double*)malloc(sizeof(double));

在堆上动态分配一个双精度浮点型变量。

上述代码中，以下代码：


    
    
  1.     *pd = 123.456;

将动态分配的双精度浮点型变量赋值。

上述代码中，以下代码：


    
    
  1.     printf("*pd = %lf\n", *pd);

使用printf函数输出动态变量的值。

上述代码中，以下代码：


    
    
  1.     free(pd);

释放动态变量所占的存储空间。

上述代码中，以下代码：


    
    
  1.     char *pstr = (char*)malloc(1024);

在堆上动态分配一个字符型数组。

上述代码中，以下代码：


    
    
  1.     strcpy(pstr, "将字符串放在堆上");

将字符型数组赋值为字符串。

上述代码中，以下代码：


    
    
  1.     printf("%s\n", pstr);

使用printf函数输出动态字符型数组。

上述代码中，以下代码：


    
    
  1.     free(pstr);

释放动态字符型数组所占的存储空间。

2.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. int main()
  6. {
  7.     int *pi = (int*)malloc(sizeof(int));
  8.     *pi = 10;
  9.     printf("*pi = %d\n", *pi);
  10.     free(pi);
  11.     
  12.     float *pf = (float*)malloc(sizeof(float));
  13.     *pf = 10.23;
  14.     printf("*pf = %f\n", *pf);
  15.     free(pf);
  16.     
  17.     double *pd = (double*)malloc(sizeof(double));
  18.     *pd = 123.456;
  19.     printf("*pd = %lf\n", *pd);
  20.     free(pd);
  21.     
  22.     char *pstr = (char*)malloc(1024);
  23.     strcpy(pstr, "将字符串放在堆上");
  24.     printf("%s\n", pstr);
  25.     free(pstr);
  26.     
  27.     return 0;
  28. }

3 动态分配内存(续1)

3.1 问题

动态分配整型数组和结构的内存，并进行数据存储和取出打印。(最后记得用free()释放)

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：动态分配内存(续1)

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.     int *array = (int *)malloc(sizeof(int) * 10);
  7.     for (int i = 0; i < 10; i++)
  8.         array[i] = i + 1;
  9.     for (int i = 0; i < 10; i++)
  10.         printf("%d ", array[i]);
  11.     printf("\n");
  12.     free(array);
  13.     
  14.     struct Data
  15.     {
  16.         int a;
  17.         double b;
  18.         char c;
  19.     };
  20.     struct Data *p = (struct Data*)malloc(sizeof(struct Data));
  21.     p->a = 10;
  22.     p->b = 12.34;
  23.     p->c = 'a';
  24.     printf("%d %lf %c\n", p->a, p->b, p->c);
  25.     free(p);
  27.     return 0;
  28. }

上述代码中，以下代码：


    
    
  1.     int *array = (int *)malloc(sizeof(int) * 10);

在堆上定义了一个整型数组。该数组共有10个元素。

上述代码中，以下代码：


    
    
  1.     for (int i = 0; i < 10; i++)
  2.         array[i] = i + 1;

使用循环对堆上的数组元素进行逐个赋值。

上述代码中，以下代码：


    
    
  1.     for (int i = 0; i < 10; i++)
  2.         printf("%d ", array[i]);
  3.     printf("\n");

使用循环遍历输出堆上的数组中的所有元素。

上述代码中，以下代码：


    
    
  1.     free(array);

释放堆上的整型数组。

上述代码中，以下代码：


    
    
  1.     struct Data
  2.     {
  3.         int a;
  4.         double b;
  5.         char c;
  6.     };

定义一个结构体Data，有三个成员，整型变量a，双精度浮点型变量b，字符型变量c。

上述代码中，以下代码：


    
    
  1.     struct Data *p = (struct Data*)malloc(sizeof(struct Data));

在堆上动态分配一个结构体Data的变量。

上述代码中，以下代码：


    
    
  1.     p->a = 10;
  2.     p->b = 12.34;
  3.     p->c = 'a';

対堆上的结构体变量的每个成员进行赋值。

上述代码中，以下代码：


    
    
  1.     printf("%d %lf %c\n", p->a, p->b, p->c);

使用printf函数输出堆上的结构体Data的变量。

上述代码中，以下代码：


    
    
  1.     free(p);

释放堆上的结构体Data的变量。

3.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main()
  5. {
  6.     int *array = (int *)malloc(sizeof(int) * 10);
  7.     for (int i = 0; i < 10; i++)
  8.         array[i] = i + 1;
  9.     for (int i = 0; i < 10; i++)
  10.         printf("%d ", array[i]);
  11.     printf("\n");
  12.     free(array);
  13.     
  14.     struct Data
  15.     {
  16.         int a;
  17.         double b;
  18.         char c;
  19.     };
  20.     struct Data *p = (struct Data*)malloc(sizeof(struct Data));
  21.     p->a = 10;
  22.     p->b = 12.34;
  23.     p->c = 'a';
  24.     printf("%d %lf %c\n", p->a, p->b, p->c);
  25.     free(p);
  27.     return 0;
  28. }

4 时间函数的使用

4.1 问题

打印年月日小时分秒格式的系统当前时间。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：时间函数的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  4. int main()
  5. {
  6.     time_t t = time(0);
  7.     struct tm * local = localtime(&t);
  8.     printf("%d年%d月%d日 %d:%d:%d\n", 1900 + local->tm_year, local->tm_mon + 1, local->tm_mday, local->tm_hour, local->tm_min, local->tm_sec);
  10.     return 0;
  11. }

上述代码中，以下代码：


    
    
  1.     time_t t = time(0);

使用函数time获取当前系统时间。

上述代码中，以下代码：


    
    
  1.     struct tm * local = localtime(&t);

将系统时间转换成本地时间。

上述代码中，以下代码：


    
    
  1.     printf("%d年%d月%d日 %d:%d:%d\n", 1900 + local->tm_year, local->tm_mon + 1, local->tm_mday, local->tm_hour, local->tm_min, local->tm_sec);

使用printf函数输出本地时间。

4.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <time.h>
  4. int main()
  5. {
  6.     time_t t = time(0);
  7.     struct tm * local = localtime(&t);
  8.     printf("%d年%d月%d日 %d:%d:%d\n", 1900 + local->tm_year, local->tm_mon + 1, local->tm_mday, local->tm_hour, local->tm_min, local->tm_sec);
  10.     return 0;
  11. }

输入输出函数（IO）

1 打开文件

1.1 问题

用各种模式打开文件。

1.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：格式化输入输出

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","w");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     fclose(fp);
  12.     fp=NULL;
  13.     
  14.     fp=fopen("file.c","a");
  15.     if(NULL==fp)
  16.     {
  17.         return -1;
  18.     }
  19.     fclose(fp);
  20.     fp=NULL;
  21.     
  22.     fp=fopen("file.c","r");
  23.     if(NULL==fp)
  24.     {
  25.         return -1;
  26.     }
  27.     fclose(fp);
  28.     fp=NULL;
  29.     
  30.     return 0;
  31. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }
  6.     fclose(fp);
  7.     fp=NULL;

首先，使用函数fopen打开一个文件，该函数有两个参数，说明如下：

第一个参数为字符串包含欲打开的文件路径及文件名。

第二个参数为字符串代表文件打开方式。

在上述语句中，打开的文件名为当前目录下的file.c。使用w方式打开，该方式打开只写文件，若文件存在则清空原文件，若不存在新建。

然后，使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","a");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }
  6.     fclose(fp);
  7.     fp=NULL;

首先，使用函数fopen打开一个文件。

在上述语句中，打开的文件名为当前目录下的file.c。使用a方式打开，该方式以追加的方式打开只写文件，若文件存在则在最后追加写入，若不存在新建。

然后，使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }
  6.     fclose(fp);
  7.     fp=NULL;

首先，使用函数fopen打开一个文件。

在上述语句中，打开的文件名为当前目录下的file.c。使用r方式打开，该方式打开只读文件，该文件必须存在。

然后，使用函数fclose关闭打开的文件。

1.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","w");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     fclose(fp);
  12.     fp=NULL;
  13.     
  14.     fp=fopen("file.c","a");
  15.     if(NULL==fp)
  16.     {
  17.         return -1;
  18.     }
  19.     fclose(fp);
  20.     fp=NULL;
  21.     
  22.     fp=fopen("file.c","r");
  23.     if(NULL==fp)
  24.     {
  25.         return -1;
  26.     }
  27.     fclose(fp);
  28.     fp=NULL;
  29.     
  30.     return 0;
  31. }

2 使用fscanf()和fprintf()读写文件

2.1 问题

fscanf函数的功能是从一个流中执行格式化输入,fscanf遇到空格和换行时结束。

fprintf函数的功能是传送格式化输出到一个文件中。

2.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：使用fscanf()和fprintf()读写文件

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","w");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     
  12.     int a = 10;
  13.     float f = 12.34;
  14.     double d = 12345.6789;
  15.     char c = 'a';
  16.     
  17.     fprintf(fp, "%c %d %f %lf", c, a, f, d);
  18.     
  19.     fclose(fp);
  20.     fp=NULL;
  21.     
  22.     fp=fopen("file.c","r");
  23.     if(NULL==fp)
  24.     {
  25.         return -1;
  26.     }
  27.     
  28.     char c1;
  29.     int a1;
  30.     float f1;
  31.     double d1;
  32.     
  33.     fscanf(fp, "%c%d%f%lf", &c1, &a1, &f1, &d1);
  34.     printf("%c\n%d\n%f\n%lf\n", c1, a1, f1, d1);
  35.     
  36.     fclose(fp);
  37.     fp=NULL;
  38.     
  39.     return 0;
  40. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用w的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     int a = 10;
  2.     float f = 12.34;
  3.     double d = 12345.6789;
  4.     char c = 'a';

定义四个变量，并对它们进行初始化。

上述代码中，以下代码：


    
    
  1.     fprintf(fp, "%c %d %f %lf", c, a, f, d);

使用函数fprintf用格式化方法将上述四个变量写入文件中。该函数与printf使用方法非常类似。

上述代码中，以下代码：


    
    
  1.     float *pf = (float*)malloc(sizeof(float));

在堆上动态分配一个单精度浮点型变量。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

首先，使用函数fopen用r的方式重新打开文件file.c。

上述代码中，以下代码：


    
    
  1.     char c1;
  2.     int a1;
  3.     float f1;
  4.     double d1;

重新定义四个新的变量，但并不对它们进行初始化。

上述代码中，以下代码：


    
    
  1.     fscanf(fp, "%c%d%f%lf", &c1, &a1, &f1, &d1);

使用函数fscanf用格式化方法从文件file.c中读入数据到这四个新的变量中。该函数与scanf使用方法非常类似。

上述代码中，以下代码：


    
    
  1.     printf("%c\n%d\n%f\n%lf\n", c1, a1, f1, d1);

使用函数printf输出这四个新的变量值，已验证读入的效果。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

2.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","w");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     
  12.     int a = 10;
  13.     float f = 12.34;
  14.     double d = 12345.6789;
  15.     char c = 'a';
  16.     
  17.     fprintf(fp, "%c %d %f %lf", c, a, f, d);
  18.     
  19.     fclose(fp);
  20.     fp=NULL;
  21.     
  22.     fp=fopen("file.c","r");
  23.     if(NULL==fp)
  24.     {
  25.         return -1;
  26.     }
  27.     
  28.     char c1;
  29.     int a1;
  30.     float f1;
  31.     double d1;
  32.     
  33.     fscanf(fp, "%c%d%f%lf", &c1, &a1, &f1, &d1);
  34.     printf("%c\n%d\n%f\n%lf\n", c1, a1, f1, d1);
  35.     
  36.     fclose(fp);
  37.     fp=NULL;
  38.     
  39.     return 0;
  40. }

3 使用fread()和fwrite()读写文件

3.1 问题

使用fwrite()和fread()读写int、double、字符串类型的数据，先写入后读取。

3.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：使用fread()和fwrite()读写文件

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main(void)
  5. {
  6.     FILE*fp=NULL;
  7.     fp=fopen("file.c","w");
  8.     if(NULL==fp)
  9.     {
  10.         return -1;
  11.     }
  12.     
  13.     int a = 10;
  14.     double d = 12345.6789;
  15.     char str[1024] = "This is a string.";
  16.     
  17.     fwrite(&a, sizeof(int), 1, fp);
  18.     fwrite(&d, sizeof(double), 1, fp);
  19.     int len = strlen(str) + 1;
  20.     fwrite(&len, sizeof(int), 1, fp);
  21.     fwrite(str, sizeof(char), len, fp);
  22.     
  23.     fclose(fp);
  24.     fp=NULL;
  25.     
  26.     fp=fopen("file.c","r");
  27.     if(NULL==fp)
  28.     {
  29.         return -1;
  30.     }
  31.     
  32.     int a1;
  33.     double d1;
  34.     char str1[1024];
  35.     
  36.     fread(&a1, sizeof(int), 1, fp);
  37.     fread(&d1, sizeof(double), 1, fp);
  38.     int len1;
  39.     fread(&len1, sizeof(int), 1, fp);
  40.     fread(str1, sizeof(char), len, fp);
  41.     printf("%d\n%lf\n%s\n", a1, d1, str1);
  43.     fclose(fp);
  44.     fp=NULL;
  45.     
  46.     return 0;
  47. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用w的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     int a = 10;
  2.     double d = 12345.6789;
  3.     char str[1024] = "This is a string.";

定义两个变量和一个数组，并对它们进行初始化。

上述代码中，以下代码：


    
    
  1.     fwrite(&a, sizeof(int), 1, fp);

使用fwrite函数将变量a写入文件。该函数有四个参数，说明如下：

第一个参数为是一个指针，是要获取写入文件的数据的地址。

第二个参数为要写入内容的单字节数。

第三个参数为要进行写入第二个参数中字节的数据项的个数。

第四个参数为目标文件指针。

上述代码中，以下代码：


    
    
  1.     fwrite(&d, sizeof(double), 1, fp);

使用fwrite函数将变量d写入文件。

上述代码中，以下代码：


    
    
  1.     int len = strlen(str) + 1;
  2.     fwrite(&len, sizeof(int), 1, fp);
  3.     fwrite(str, sizeof(char), len, fp);

使用fwrite函数将字符数组str写入文件。写入字符数组时，应先将该数组中字符串的长度存入文件，再存入字符串本身，这样有理由读文件时，定义读取字符串的长度。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式重新打开文件file.c。

上述代码中，以下代码：


    
    
  1.     int a1;
  2.     double d1;
  3.     char str1[1024];

重新定义两个变量和一个数组，但并不对它们进行初始化。

上述代码中，以下代码：


    
    
  1.     fread(&a1, sizeof(int), 1, fp);

使用fread函数从文件中读入数据放在变量a1中。该函数有四个参数，说明如下：

第一个参数为是一个指针，是要将获取的数据写入到的地址。

第二个参数为要读取内容的单字节数。

第三个参数为要进行读取第二个参数中字节的数据项的个数。

第四个参数为目标文件指针。

上述代码中，以下代码：


    
    
  1.     fread(&d1, sizeof(double), 1, fp);

使用fread函数从文件中读入数据放在变量d1中。

上述代码中，以下代码：


    
    
  1.     int len1;
  2.     fread(&len1, sizeof(int), 1, fp);
  3.     fread(str1, sizeof(char), len, fp);

使用fread函数从文件中读入数据放在字符数组str中。在读取字符串前，先读取该字符串的长度，然后根据长度读取字符串的内容。

上述代码中，以下代码：


    
    
  1.     printf("%d\n%lf\n%s\n", a1, d1, str1);

使用printf函数验证读取的内容是否正确。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

3.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main(void)
  5. {
  6.     FILE*fp=NULL;
  7.     fp=fopen("file.c","w");
  8.     if(NULL==fp)
  9.     {
  10.         return -1;
  11.     }
  12.     
  13.     int a = 10;
  14.     double d = 12345.6789;
  15.     char str[1024] = "This is a string.";
  16.     
  17.     fwrite(&a, sizeof(int), 1, fp);
  18.     fwrite(&d, sizeof(double), 1, fp);
  19.     int len = strlen(str) + 1;
  20.     fwrite(&len, sizeof(int), 1, fp);
  21.     fwrite(str, sizeof(char), len, fp);
  22.     
  23.     fclose(fp);
  24.     fp=NULL;
  25.     
  26.     fp=fopen("file.c","r");
  27.     if(NULL==fp)
  28.     {
  29.         return -1;
  30.     }
  31.     
  32.     int a1;
  33.     double d1;
  34.     char str1[1024];
  35.     
  36.     fread(&a1, sizeof(int), 1, fp);
  37.     fread(&d1, sizeof(double), 1, fp);
  38.     int len1;
  39.     fread(&len1, sizeof(int), 1, fp);
  40.     fread(str1, sizeof(char), len, fp);
  41.     printf("%d\n%lf\n%s\n", a1, d1, str1);
  43.     fclose(fp);
  44.     fp=NULL;
  45.     
  46.     return 0;
  47. }

4 使用fread()和fwrite()读写文件(续1)

4.1 问题

输入学生信息(学号、姓名、出生日期)，然后用结构存储数据，并读写入文件中。

4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：使用fread()和fwrite()读写文件(续1)

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. struct student
  5. {
  6.     int id;
  7.     char name[20];
  8.     char address[200];
  9. };
  11. int main(void)
  12. {
  13.     FILE*fp=NULL;
  14.     fp=fopen("file.c","w");
  15.     if(NULL==fp)
  16.     {
  17.         return -1;
  18.     }
  20.     struct student stu = {10000, "zhangsan", "江苏南京"};
  21.     
  22.     fwrite(&stu, sizeof(struct student), 1, fp);
  23.     
  24.     fclose(fp);
  25.     fp=NULL;
  26.     
  27.     fp=fopen("file.c","r");
  28.     if(NULL==fp)
  29.     {
  30.         return -1;
  31.     }
  32.     
  33.     struct student stu1;
  34.     
  35.     fread(&stu1, sizeof(struct student), 1, fp);
  36.     printf("%d %s %s\n", stu1.id, stu1.name, stu1.address);
  38.     fclose(fp);
  39.     fp=NULL;
  40.     
  41.     return 0;
  42. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用w的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     struct student stu = {10000, "zhangsan", "江苏南京"};

定义一个结构体student的变量stu，并对它进行初始化。

上述代码中，以下代码：


    
    
  1.     fwrite(&stu, sizeof(struct student), 1, fp);

使用fwrite函数将结构体student的变量stu写入文件。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式重新打开文件file.c。

上述代码中，以下代码：


    
    
  1.     struct student stu1;

重新定义一个结构体student的变量stu1，但并不对它进行初始化。

上述代码中，以下代码：


    
    
  1.     fread(&stu1, sizeof(struct student), 1, fp);

使用fread函数从文件中读入数据放在结构体student的变量stu1中。

上述代码中，以下代码：


    
    
  1.     printf("%d %s %s\n", stu1.id, stu1.name, stu1.address);

使用printf函数验证读取的内容是否正确。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

4.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. struct student
  5. {
  6.     int id;
  7.     char name[20];
  8.     char address[200];
  9. };
  11. int main(void)
  12. {
  13.     FILE*fp=NULL;
  14.     fp=fopen("file.c","w");
  15.     if(NULL==fp)
  16.     {
  17.         return -1;
  18.     }
  20.     struct student stu = {10000, "zhangsan", "江苏南京"};
  21.     
  22.     fwrite(&stu, sizeof(struct student), 1, fp);
  23.     
  24.     fclose(fp);
  25.     fp=NULL;
  26.     
  27.     fp=fopen("file.c","r");
  28.     if(NULL==fp)
  29.     {
  30.         return -1;
  31.     }
  32.     
  33.     struct student stu1;
  34.     
  35.     fread(&stu1, sizeof(struct student), 1, fp);
  36.     printf("%d %s %s\n", stu1.id, stu1.name, stu1.address);
  38.     fclose(fp);
  39.     fp=NULL;
  40.     
  41.     return 0;
  42. }

5 fseek()的使用

5.1 问题

测试fseek()的效果，包括三个不同的起始位置。

5.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：fseek()的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main(void)
  5. {
  6.     FILE*fp=NULL;
  7.     fp=fopen("file.c","w+");
  8.     if(NULL==fp)
  9.     {
  10.         return -1;
  11.     }
  13.     char buf[] = "abcdefghijklmnopqrstuvwxyz";
  14.     
  15.     fwrite(buf, sizeof(char), 26, fp);
  16.     
  17.     fseek(fp, 0, SEEK_SET);
  18.     memset(buf, 0, 26);
  19.     fread(buf, sizeof(char), 10, fp);
  20.     printf("%s\n", buf);
  21.     
  22.     fseek(fp, 5, SEEK_CUR);
  23.     memset(buf, 0, 26);
  24.     fread(buf, sizeof(char), 10, fp);
  25.     printf("%s\n", buf);
  26.     
  27.     fseek(fp, -10, SEEK_END);
  28.     memset(buf, 0, 26);
  29.     fread(buf, sizeof(char), 10, fp);
  30.     printf("%s\n", buf);
  31.     
  32.     fclose(fp);
  33.     fp=NULL;
  34.     
  35.     return 0;
  36. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w+");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用w+的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     char buf[] = "abcdefghijklmnopqrstuvwxyz";

定义一个字符数组buf，并初始化为一个字符串。

上述代码中，以下代码：


    
    
  1.     fwrite(buf, sizeof(char), 26, fp);

使用fwrite函数将字符串buf写入文件。

上述代码中，以下代码：


    
    
  1.     fseek(fp, 0, SEEK_SET);
  2.     memset(buf, 0, 26);
  3.     fread(buf, sizeof(char), 10, fp);
  4.     printf("%s\n", buf);

首先，使用函数fseek设置文件指针fp的位置为文件头开始的第一个字节。该函数有三个参数，说明如下：

第一个参数为目标文件指针。

第二个参数为从第三个参数开始的偏移量，为正数时向后偏移，为负数时向前偏移。

第三个参数为偏移的起始位置。

然后，使用memset函数将字符串buf清空。

下一步，使用fread函数从文件当前设定位置读入10个字符。

最后，使用printf函数验证读入的字符是从文件开头第一个字节开始的10个字符。

上述代码中，以下代码：


    
    
  1.     fseek(fp, 5, SEEK_CUR);
  2.     memset(buf, 0, 26);
  3.     fread(buf, sizeof(char), 10, fp);
  4.     printf("%s\n", buf);

首先，使用函数fseek设置文件指针fp的位置为文件当前位置向后偏移5个字节的位置。

然后，使用memset函数将字符串buf清空。

下一步，使用fread函数从文件当前设定位置读入10个字符。

最后，使用printf函数验证读入的字符是从文件当前位置向后偏移5个字节开始的10个字符。

上述代码中，以下代码：


    
    
  1.     fseek(fp, -10, SEEK_END);
  2.     memset(buf, 0, 26);
  3.     fread(buf, sizeof(char), 10, fp);
  4.     printf("%s\n", buf);

首先，使用函数fseek设置文件指针fp的位置为文件尾开始向前偏移10个字节的位置。

然后，使用memset函数将字符串buf清空。

下一步，使用fread函数从文件当前设定位置读入10个字符。

最后，使用printf函数验证读入的字符是从文件尾开始向前偏移10个字节开始的10个字符。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

5.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  4. int main(void)
  5. {
  6.     FILE*fp=NULL;
  7.     fp=fopen("file.c","w+");
  8.     if(NULL==fp)
  9.     {
  10.         return -1;
  11.     }
  13.     char buf[] = "abcdefghijklmnopqrstuvwxyz";
  14.     
  15.     fwrite(buf, sizeof(char), 26, fp);
  16.     
  17.     fseek(fp, 0, SEEK_SET);
  18.     memset(buf, 0, 26);
  19.     fread(buf, sizeof(char), 10, fp);
  20.     printf("%s\n", buf);
  21.     
  22.     fseek(fp, 5, SEEK_CUR);
  23.     memset(buf, 0, 26);
  24.     fread(buf, sizeof(char), 10, fp);
  25.     printf("%s\n", buf);
  26.     
  27.     fseek(fp, -10, SEEK_END);
  28.     memset(buf, 0, 26);
  29.     fread(buf, sizeof(char), 10, fp);
  30.     printf("%s\n", buf);
  31.     
  32.     fclose(fp);
  33.     fp=NULL;
  34.     
  35.     return 0;
  36. }

6 ftell()的使用

6.1 问题

使用ftell()获取文件的大小。

6.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：ftell()的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","r");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     
  12.     fseek(fp, 0, SEEK_END);
  13.     long len = ftell(fp);
  14.     
  15.     printf("文件长度为：%ld个字节\n", len);
  16.     
  17.     fclose(fp);
  18.     fp=NULL;
  19.     
  20.     return 0;
  21. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     fseek(fp, 0, SEEK_END);

使用函数fseek设置文件指针fp的位置为文件尾开始的第一个字节。

上述代码中，以下代码：


    
    
  1.     long len = ftell(fp);

使用函数ftell获得指定文件的文件指针当前位置距离文件头的第一个字节的字节数。如果文件当前位置在文件尾开始的第一个字节，即文件最后一个字节的下一个位置，则将得到文件长度。

上述代码中，以下代码：


    
    
  1.     printf("文件长度为：%ld个字节\n", len);

打印文件长度。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

6.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp=NULL;
  6.     fp=fopen("file.c","r");
  7.     if(NULL==fp)
  8.     {
  9.         return -1;
  10.     }
  11.     
  12.     fseek(fp, 0, SEEK_END);
  13.     long len = ftell(fp);
  14.     
  15.     printf("文件长度为：%ld个字节\n", len);
  16.     
  17.     fclose(fp);
  18.     fp=NULL;
  19.     
  20.     return 0;
  21. }

7 字符的输入输出

7.1 问题

使用字符的输入输出函数实现文件的复制。

7.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符的输入输出

代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp = NULL;
  6.     fp = fopen("file.c","r");
  7.     if(NULL == fp)
  8.     {
  9.         return -1;
  10.     }
  11.     FILE*fp1 = NULL;
  12.     fp1 = fopen("file副本.c","w");
  13.     if(NULL == fp1)
  14.     {
  15.         return -1;
  16.     }
  17.     
  18.     char ch;
  19.     while ((ch = getc(fp)) != EOF)
  20.         putc(ch, fp1);
  21.     
  22.     fclose(fp);
  23.     fp=NULL;
  24.     fclose(fp1);
  25.     fp=NULL;
  26.     
  27.     return 0;
  28. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用w的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     char ch;
  2.     while ((ch = getc(fp)) != EOF)
  3.         putc(ch, fp1);

首先，在循环的结束条件处，使用函数getc从文件fp中读入一个字符。

然后，在循环体内，将读入的字符写入到另一个文件fp1中。

最后，设置一个循环，逐个字节地读入文件fp的内容，再逐个字节的写入文件fp1，直到文件fp结束，即读入的字节是EOF。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fclose(fp1);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

7.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  3. int main(void)
  4. {
  5.     FILE*fp = NULL;
  6.     fp = fopen("file.c","r");
  7.     if(NULL == fp)
  8.     {
  9.         return -1;
  10.     }
  11.     FILE*fp1 = NULL;
  12.     fp1 = fopen("file副本.c","w");
  13.     if(NULL == fp1)
  14.     {
  15.         return -1;
  16.     }
  17.     
  18.     char ch;
  19.     while ((ch = getc(fp)) != EOF)
  20.         putc(ch, fp1);
  21.     
  22.     fclose(fp);
  23.     fp=NULL;
  24.     fclose(fp1);
  25.     fp=NULL;
  26.     
  27.     return 0;
  28. }

8 字符串函数的使用

8.1 问题

使用sscanf()和sprintf()处理字符串。

8.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：字符串函数的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. int main(void)
  6. {
  7.     FILE*fp=NULL;
  8.     fp=fopen("file.c","w");
  9.     if(NULL==fp)
  10.     {
  11.         return -1;
  12.     }
  13.     
  14.     char buf[] = "abcdefghijklmnopqrstuvwxyz";
  15.     fprintf(fp, "%lu%s", strlen(buf), buf);
  16.     
  17.     fclose(fp);
  18.     fp=NULL;
  19.     
  20.     fp=fopen("file.c","r");
  21.     if(NULL==fp)
  22.     {
  23.         return -1;
  24.     }
  25.     
  26.     char *buf1;
  27.     int len;
  28.     fscanf(fp, "%d", &len);
  29.     buf1 = malloc(len) + 1;
  30.     fscanf(fp, "%s", buf1);
  31.     buf1[len] = 0;
  32.     printf("%s\n", buf1);
  33.     
  34.     fclose(fp);
  35.     fp=NULL;
  36.     
  37.     return 0;
  38. }

上述代码中，以下代码：


    
    
  1.     FILE*fp=NULL;

定义一个FILE类型的指针fp。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","w");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式打开一个文件file.c。

上述代码中，以下代码：


    
    
  1.     char buf[] = "abcdefghijklmnopqrstuvwxyz";

定义一个字符数组buf，并对其进行初始化。

上述代码中，以下代码：


    
    
  1.     fprintf(fp, "%lu%s", strlen(buf), buf);

使用函数fprintf将字符数组buf保存到文件中。

注意：在保存之前应先保存字符数组buf中的字符串长度。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

上述代码中，以下代码：


    
    
  1.     fp=fopen("file.c","r");
  2.     if(NULL==fp)
  3.     {
  4.         return -1;
  5.     }

使用函数fopen用r的方式重新打开文件file.c。

上述代码中，以下代码：


    
    
  1.     char *buf1;
  2.     int len;

首先，定义一个字符指针buf1。

然后，定义一个整型变量len。

上述代码中，以下代码：


    
    
  1.     fscanf(fp, "%d", &len);
  2.     buf1 = malloc(len) + 1;

首先，使用fscanf函数从文件中读入字符串的长度到变量len中。

然后，根据len中的值使用malloc函数为字符指针buf1申请存储空间。加1是为了给字符串结束符\0留出位置。

上述代码中，以下代码：


    
    
  1.     fscanf(fp, "%s", buf1);
  2.     buf1[len] = 0;
  3.     printf("%s\n", buf1);

首先，使用fscanf函数从文件中从文件中读入字符串。

然后，将字符数组buf1中的最后一个字节置为\0。

最后，使用printf函数验证读入的内容。

上述代码中，以下代码：


    
    
  1.     fclose(fp);
  2.     fp=NULL;

使用函数fclose关闭打开的文件。

8.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  5. int main(void)
  6. {
  7.     FILE*fp=NULL;
  8.     fp=fopen("file.c","w");
  9.     if(NULL==fp)
  10.     {
  11.         return -1;
  12.     }
  13.     
  14.     char buf[] = "abcdefghijklmnopqrstuvwxyz";
  15.     fprintf(fp, "%lu%s", strlen(buf), buf);
  16.     
  17.     fclose(fp);
  18.     fp=NULL;
  19.     
  20.     fp=fopen("file.c","r");
  21.     if(NULL==fp)
  22.     {
  23.         return -1;
  24.     }
  25.     
  26.     char *buf1;
  27.     int len;
  28.     fscanf(fp, "%d", &len);
  29.     buf1 = malloc(len) + 1;
  30.     fscanf(fp, "%s", buf1);
  31.     buf1[len] = 0;
  32.     printf("%s\n", buf1);
  33.     
  34.     fclose(fp);
  35.     fp=NULL;
  36.     
  37.     return 0;
  38. }

9 可变长参数的使用

9.1 问题

可变长函数参数是指定义一个函数，该函数的参数个数为不确定的值，如printf函数。

9.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：可变长参数的使用

代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdarg.h>
  4. int max(int cnt, ...)
  5. {
  6.     va_list v;
  7.     va_start(v, cnt);
  9.     int maxvalue = va_arg(v, int);
  10.     for(int i = 1; i < cnt; i++)
  11.     {
  12.         int data = va_arg(v, int);
  13.         if(data > maxvalue)
  14.             maxvalue = data;
  15.     }
  16.     va_end(v);
  18.     return maxvalue;
  19. }
  21. int main(void)
  22. {
  23.     int maxNum = max(10, 55, 34, 28, 16, 47, 62, 77, 86, 91, 9);
  24.     printf("最大数为：%d\n", maxNum);
  25.     
  26.     return 0;
  27. }

上述代码中，以下代码：


    
    
  1. int max(int cnt, ...)
  2. {
  3.     va_list v;
  4.     va_start(v, cnt);
  6.     int maxvalue = va_arg(v, int);
  7.     for(int i = 1; i < cnt; i++)
  8.     {
  9.         int data = va_arg(v, int);
  10.         if(data > maxvalue)
  11.             maxvalue = data;
  12.     }
  13.     va_end(v);
  15.     return maxvalue;
  16. }

定义了一个函数max。用于求参数中的最大值。在该函数中，以下语句：


    
    
  1.     va_list v;

定义可变长参数表变量v。在该函数中，以下语句：


    
    
  1.     va_start(v, cnt);

使用函数va_start将参数cnt之后的那些参数保存到v中。在该函数中，以下语句：


    
    
  1.     int maxvalue = va_arg(v, int);

使用函数va_arg从参数表中取一个int类型参数放入变量maxvalue中，并假设maxvalue保存的是所有参数中的最大值。在该函数中，以下语句：


    
    
  1.         int data = va_arg(v, int);
  2.         if(data > maxvalue)
  3.             maxvalue = data;

首先，使用函数va_arg从参数表中取一个int类型参数放入变量data中。

然后，将变量data与变量maxvalue对比，如果data大于maxvalue，则将data赋值给maxvalue，以保证maxvalue中保存的永远是最大值。在该函数中，以下语句：


    
    
  1.     for(int i = 1; i < cnt; i++)
  2.     {
  3.         int data = va_arg(v, int);
  4.         if(data > maxvalue)
  5.             maxvalue = data;
  6.     }

设置循环，将cnt后的参数，逐个遍历，找出最大值。在该函数中，以下语句：


    
    
  1.     va_end(v);

使用函数va_end释放可变长参数表v。

上述代码中，以下代码：


    
    
  1. int main(void)
  2. {
  3.     int maxNum = max(10, 55, 34, 28, 16, 47, 62, 77, 86, 91, 9);
  4.     printf("最大数为：%d\n", maxNum);

在主函数中，使用函数max，找出参数中的最大值，并输出。

9.3 完整代码

本案例的完整代码如下所示：


    
    
  1. #include <stdio.h>
  2. #include <stdarg.h>
  4. int max(int cnt, ...)
  5. {
  6.     va_list v;
  7.     va_start(v, cnt);
  9.     int maxvalue = va_arg(v, int);
  10.     for(int i = 1; i < cnt; i++)
  11.     {
  12.         int data = va_arg(v, int);
  13.         if(data > maxvalue)
  14.             maxvalue = data;
  15.     }
  16.     va_end(v);
  18.     return maxvalue;
  19. }
  21. int main(void)
  22. {
  23.     int maxNum = max(10, 55, 34, 28, 16, 47, 62, 77, 86, 91, 9);
  24.     printf("最大数为：%d\n", maxNum);
  25.     
  26.     return 0;
  27. }



opera92
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言程序设计——函数（递归）
XLZ_44847的博客
04-26 2447
递归是个很棒的思想，在处理某些问题时常常能发挥奇效。掌握其主要思想，保证实现大事化小的思想，好比高中数学数列之中的递推公式，把握住两层表达式（问题）之间的联系就是解决问题的关键，慢慢悟好好学！本文为学习C语言心得与笔记记录，部分举例来源于B站C语言教学up主鹏哥。
【C++习题笔记】谭浩强C++程序设计（第三版）第四章
zl3090的博客
12-03 4067
1. 写两个函数,分别求两个整数的最大公约数和最小公倍数,用主函数调用这两个函数,并输出结果 //两个函数求最大公约数和最小公倍数 #include &lt;iostream&gt; using namespace std; int main() { int a,b,c,d; int maxcm(int a, int b); int mincd(int a, int b); cin &...
C语言 递归算法计算函数F(n)的各项值
weixin_74287172的博客
04-04 815
3）在主函数中输出各项值（每行5项，每项格式“%12d”）2）编写递归函数实现求第n项的函数值；1）从键盘输入正整数n（n<45）；
c语言函数求值
最新发布
w30801314的博客
11-17 128
给定正整数N，函数F(N)表示小于等于N的自然数中1和2的个数之和，例如：1,2,3,4,5,6,7,8,9,10序列中1和2的个数之和为3，因此 F(10)=3。输入N，求F(N)的值，1=<N<=10^100(10的100次方)若F(N)很大，则求F(N)mod20123的值。看到其他文章有些很复杂，对于我这个初学者很难看懂，太多了，下面给定一种简单方法。int number(int a) //求数字位数。int num(int a)//每位数的值。这两个函数用的很好（借鉴来的）
定义一个函数，并用递归方式n的阶乘 C语言
weixin_63545309的博客
11-22 884
#include<stdio.h> int main() { int f(int n);/*函数类型，实参类型*/ int n,temp;/*定义实参*/ printf("Input the nunumber wich you want."); scanf("%d",&n); temp=f(n); printf("n!= %d",temp); } int f(int n)/*定义函数类型，形参类型，返回值类型*/ { ...
C语言函数递归
cyrilcloud的博客
05-07 232
目录函数递归什么是递归递归的两个必要条件 函数递归 什么是递归 程序调用自身的编程技巧称为递归（recursion）。递归作为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小。 递归的两个必要条件 存在限制条件，当满足这个限制条件的时候，递归便不再继续。 每次
C语言递归函数的使用
m0_46678155的博客
03-29 2893
我是小白！ 我是小白！！ 我是小白！！！ 重要的事情说三遍，大神请绕道…当然能指教一二是非常非常感谢的！！！！ 刚开始学习C语言程序设计课，对各种代码啊函数啊啥的都秉持黑人问号态度（哭），于是每当到了提交程序设计实验报告的时候都是步履蹒跚地敲下一个个自己都认不出来的代码… 在一个风和日丽的今天中午，我踌躇满志地打开作业里的题目：老师在讲课的时候画上去的，不是我不是我不是我。。。 很明显，题目要求编...
C语言函数的递归和调用实例分析
09-05
2. **直接递归与间接递归**：直接递归是指函数直接调用自身，而间接递归则是通过其他函数调用来实现函数自身的调用。这里我们主要讨论直接递归。 **二、递归条件** 1. **问题转化**：递归解决问题的关键在于将原...
C语言递归函数的学习与运用
06-25
在C语言中，递归函数是一种特殊的编程技巧，它使得函数能够调用自身来解决问题。递归在理解和实现上可能有些复杂，但是一旦掌握，它可以帮助我们解决很多抽象和结构化的问题。本文将深入探讨C语言中的递归函数，包括...
C语言的函数递归探析-综合文档
05-14
函数递归是C语言中一个非常重要的概念，它允许函数在其定义中调用自身，以解决复杂问题。本篇文章将深入探讨C语言中的函数递归，包括其原理、实现方式以及实际应用。 首先，我们需要理解什么是函数递归。函数递归是...
C语言的函数递归探析.zip-综合文档
05-20
在C语言中，函数是实现模块化编程的关键元素，而函数递归则是函数使用的一种高级技巧，能够解决许多复杂问题。本文将深入探讨C语言中的函数递归及其相关知识点。 首先，我们要理解什么是函数递归。函数递归是指一个...
c语言中的函数
m0_64162358的博客
02-14 239
先举一个例子 #include<stdio.h> void print_C(); //函数的声明,声明语句，后面有一个分号 void print_C() //函数的定义 { printf(" ###### \n"); printf("## ##\n"); printf("## \n"); printf("## \n"); printf("## \n"); printf("## ##\n"); printf(
递归函数取值
qq_43235503的博客
11-19 588
递归函数取值
1396. 递归函数求值
一键难忘的博客
08-18 1040
递归函数求值 时间限制：1Sec内存限制：128MB通过：316提交：522 递归 题目描述 按如下递归公式求函数值：x=1时，f(x)=10；x>1时，f(x)=f(x-1)+2。 输入 整型变量x（0 < x < 10000）。 输出 f(x)的值。 样例输入 10 样例输出 28 来源 2017 大一限时训练（一） #include<bits/stdc++.h> using namespace std; int po(int x) { if(x==1) .
递归函数详解
热门推荐
Lianuuu的博客
10-08 2万+
文章目录1. 什么是递归函数2. 递归求阶乘3. 递归的进入4. 递归的退出5. 递归的条件 1. 什么是递归函数 一个函数在它的函数体内调用它自身称为递归调用，这种函数称为递归函数。执行递归函数将反复调用其自身，每调用一次就进入新的一层，当最内层的函数执行完毕后，再一层一层地由里到外退出。 一句话总结递归：自我调用且有完成状态 2. 递归求阶乘 举个例子，我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数factorial(n)表示，可以看出： 所以，factorial(n)
递归函数及例题
a123321a1233211的博客
09-11 6398
定义： 一种计算过程，如果其中每一步都要用到前一步或前几步的结果，称为递归的。用递归过程定义的函数，称为递归函数，例如连加、连乘及阶乘等。凡是递归的函数，都是可计算的，即能行的 。 古典递归函数，是一种定义在自然数集合上的函数，它的未知值往往要通过有限次运算回归到已知值来求出，故称为“递归”。它是古典递归函数论的研究对象 。 条件： 1 递归出口即结束条件； 2 递推关系； 例题1：求任意正整数的逆置数 示例1： 输入： 890 输出 解题思路： 1 递归出口： n=0时可结束 2 递推关系： 使用变量
编程小白C语言数组3
linux2422988311的博客
05-13 550
题目要求 求该代码最后的输出结果 #include<stdio.h> int f1(int n[]) { n[0] = n[0] + 1; } int main() { int n[3]={1,2,3}; int i; f1(n); for(i=0;i<3;i++) { printf("n[%d]=%d\n",i,n[i]); } return 0; } 思路分析 首先得知道f1( int n [ ])的int n[ ],和下面的int n[3.
问题 E: C语言：递归函数4（连续偶数和）
m0_51374762的博客
05-04 1376
题目描述 输入偶数n（n<1000），编写递归函数计算2+4+6+8+……+n。 输入 偶数n。 输出 2+4+6+8+……+n的值 样例输入 Copy 10 样例输出 Copy 30 # include <stdio.h> # include <stdlib.h> int sum(int n) { if(n == 2) { return 2; } return sum(n-2) + n; } int main() { int n; scanf("%d"
洛谷【C++编程基础】递归函数初步 专题解题报告
GaoGuohao2022的博客
12-05 1134
T89304 递归求和 T89307 Hermite多项式 T89310 递归函数求值1 T89314 递归函数求值2 T89316 汉诺塔问题 T90615 字符串逆序 T90627 费波那契数列 T90628 F91 T90630 最大公约数与最小公倍数 T90632 十进制转八进制 T90633 走台阶
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值