函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数main()，所有简单的程序都可以定义其他额外的函数。 您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的，但在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。 函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。 C 标准库提供了大量的程序可以调用的内置函数。例如，

  • 函数strcat()用来连接两个字符串
  • 函数memcpy()用来复制内存到另一个位置

函数还有很多叫法，比如方法、子例程或程序，等等。

定义函数

C 语言中的函数定义的一般形式如下：

  1. return_type function_name( parameter list )
  2. {
  3.    body of the function
  4. }

在 C 语言中，函数由一个函数头和一个函数主体组成。下面列出一个函数的所有组成部分：

  • 返回类型：一个函数可以返回一个值。return_type是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字void。
  • 函数名称：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
  • 参数：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
  • 函数主体：函数主体包含一组定义函数执行任务的语句。

以下是max()函数的源代码。该函数有两个参数 num1 和 num2，会返回这两个数中较大的那个数：

  1. /* 函数返回两个数中较大的那个数 */
  2. int max(int num1, int num2) 
  3. {
  4.    /* 局部变量声明 */
  5.    int result;
  7.    if (num1 > num2)
  8.       result = num1;
  9.    else
  10.       result = num2;
  12.    return result; 
  13. }

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数声明包括以下几个部分：

  1. return_type function_name( parameter list );

针对上面定义的函数 max()，以下是函数声明：

  1. int max(int num1, int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

  1. int max(int, int);

当您在一个源文件中定义函数且在另一个文件中调用函数时，函数声明是必需的。在这种情况下，您应该在调用函数的文件顶部声明函数。

调用函数

创建 C 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。
当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。
调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

  1. #include <stdio.h>
  3. /* 函数声明 */
  4. int max(int num1, int num2);
  6. int main ()
  7. {
  8.    /* 局部变量定义 */
  9.    int a = 100;
  10.    int b = 200;
  11.    int ret;
  13.    /* 调用函数来获取最大值 */
  14.    ret = max(a, b);
  16.    printf( "Max value is : %d\n", ret );
  18.    return 0;
  19. }
  21. /* 函数返回两个数中较大的那个数 */
  22. int max(int num1, int num2) 
  23. {
  24.    /* 局部变量声明 */
  25.    int result;
  27.    if (num1 > num2)
  28.       result = num1;
  29.    else
  30.       result = num2;
  32.    return result; 
  33. }

把 max() 函数和 main() 函数放一块，编译源代码。当运行最后的可执行文件时，会产生下列结果：

  1. Max value is : 200

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的形式参数。
形式参数就像函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。
当调用函数时，有两种向函数传递参数的方式：

调用类型 描述
传值调用 该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数
指针调用 通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作

默认情况下，C 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的实际参数。

传值方式

向函数传递参数的传值调用方法，把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
默认情况下，C 语言使用传值调用方法来传递参数。一般来说，这意味着函数内的代码不会改变用于调用函数的实际参数。函数swap()定义如下：

  1. #include <stdio.h>
  3. void swap(int x, int y); // 函数声明
  4. int main()
  5. {
  6.      int a = 100;
  7.      int b = 200;
  8.      printf("交换前，a 的值： %d\n", a);
  9.      printf("交换前，b 的值： %d\n", b);
  10.      swap(a, b); // 调用函数来交换值
  11.      printf("交换后，a 的值： %d\n", a);
  12.      printf("交换后，b 的值： %d\n", b);
  13.      return 0;
  14. }
  16. void swap(int x, int y)
  17. {
  18.      int temp;
  19.      temp = x; // 保存 x 的值
  20.      x = y;    // 把 y 赋值给 x
  21.      y = temp; // 把 temp 赋值给 y
  22.      return;
  23. }
  25. /* 
  26. 交换前，a 的值： 100
  27. 交换前，b 的值： 200
  28. 交换后，a 的值： 100
  29. 交换后，b 的值： 200 
  30. */

指针方式

通过引用传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。
传递指针可以让多个函数访问指针所引用的对象，而不用把对象声明为全局可访问。

  1. #include <stdio.h>
  3. void swap(int *x, int *y); // 函数声明
  5. int main()
  6. {
  7.      int a = 100;
  8.      int b = 200;
  9.      printf("交换前，a 的值： %d\n", a);
  10.      printf("交换前，b 的值： %d\n", b);
  11.      /* 
  12.        调用函数来交换值
  13.        &a 表示指向 a 的指针，即变量 a 的地址
  14.        &b 表示指向 b 的指针，即变量 b 的地址    
  15.      */
  16.      swap(&a, &b);
  17.      printf("交换后，a 的值： %d\n", a);
  18.      printf("交换后，b 的值： %d\n", b);
  19.      return 0;
  20. }
  22. //函数定义
  23. void swap(int *x, int *y)
  24. {
  25.      int temp;
  26.      temp = *x; // 保存地址 x 的值
  27.      *x = *y;   // 把 y 赋值给 x
  28.      *y = temp; // 把 temp 赋值给 y
  29.      return;
  30. }
  32. /* 
  33. 交换前，a 的值： 100
  34. 交换前，b 的值： 200
  35. 交换后，a 的值： 200
  36. 交换后，b 的值： 100 
  37. */

可变参数

有时，您可能会碰到这样的情况，您希望函数带有可变数量的参数，而不是预定义数量的参数。C 语言为这种情况提供了一个解决方案，它允许您定义一个函数，能根据具体的需求接受可变数量的参数。下面的实例演示了这种函数的定义。

  1. int func(int, ... ) {  }
  4. int main()
  5. {
  6.    func(2, 2, 3);
  7.    func(3, 2, 3, 4);
  8. }

请注意，函数func()最后一个参数写成省略号，即三个点号（…），省略号之前的那个参数是int，代表了要传递的可变参数的总数。为了使用这个功能，您需要使用stdarg.h头文件，该文件提供了实现可变参数功能的函数和宏。具体步骤如下：

  • 定义一个函数，最后一个参数为省略号，省略号前面可以设置自定义参数。
  • 在函数定义中创建一个va_list类型变量，该类型是在 stdarg.h 头文件中定义的。
  • 使用int参数和va_start宏来初始化va_list变量为一个参数列表。宏 va_start 是在 stdarg.h 头文件中定义的。
  • 使用va_arg宏和va_list变量来访问参数列表中的每个项。
  • 使用宏va_end来清理赋予va_list变量的内存。

现在让我们按照上面的步骤，来编写一个带有可变数量参数的函数，并返回它们的平均值：

  1. #include <stdio.h>
  2. #include <stdarg.h>
  4. double average(int num, ...)
  5. {
  7.    va_list valist;
  8.    double sum = 0.0;
  9.    int i;
  11.    va_start(valist, num); // 为 num 个参数初始化 valist
  13.    // 访问所有赋给 valist 的参数
  14.    for (i = 0; i < num; i++)
  15.    {
  17.       sum += va_arg(valist, int);
  18.    }
  19.    va_end(valist); // 清理为 valist 保留的内存
  20.    return sum / num;
  21. }
  23. int main()
  24. {
  25.    printf("Average of 2, 3, 4, 5 = %f\n", average(4, 2, 3, 4, 5));
  26.    printf("Average of 5, 10, 15 = %f\n", average(3, 5, 10, 15));
  27. }
  29. /*
  30. Average of 2, 3, 4, 5 = 3.500000
  31. Average of 5, 10, 15 = 10.000000
  32. */

函数指针与回调函数

函数指针

函数指针是指向函数的指针变量。
通常我们说的指针变量是指向一个整型、字符型或数组等变量，而函数指针是指向函数。
函数指针可以像一般函数一样，用于调用函数、传递参数。
函数指针变量的声明：

  1. typedef int (*fun_ptr_name)(int,int); // 声明一个指向同样参数、返回值的函数指针类型
  3. fun_ptr_name 函数指针名字
  4. int 指针类型
  5. (int,int) 参数

以下实例声明了函数指针变量 p，指向函数 max：

  1. #include <stdio.h>
  3. int max(int x, int y)
  4. {
  5.    return x > y ? x : y;
  6. }
  8. int main(void)
  9. {
  10.    // p 是函数指针
  11.    int (*p)(int, int) = &max; // &可以省略
  12.    int a, b, c, d;
  14.    printf("请输入三个数字:");
  15.    scanf("%d %d %d", &a, &b, &c);
  17.    d = p(p(a, b), c); // 与直接调用函数等价，d = max(max(a, b), c)
  19.    printf("最大的数字是: %d\n", d);
  20.    return 0;
  21. }
  23. /* 
  24. 请输入三个数字:1 2 3
  25. 最大的数字是: 3 
  26. */

回调函数

函数指针变量可以作为某个函数的参数来使用的，回调函数就是一个通过函数指针调用的函数。
简单讲：回调函数是由别人的函数执行时调用你实现的函数。

实例中 populate_array 函数定义了三个参数，其中第三个参数是函数的指针，通过该函数来设置数组的值。
实例中我们定义了回调函数 getRandom，它返回一个随机值，它作为一个函数指针传递给 populate_array 函数。
populate_array 将调用 10 次回调函数，并将回调函数的返回值赋值给数组。

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <time.h>
  5. // 回调函数
  6. void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
  7. {
  8.    // srand((unsigned)time(NULL)); // 设置随机数种子，利用当前系统的系统
  9.    for (size_t i = 0; i < arraySize; i++)
  10.       array[i] = getNextValue();
  11. }
  13. // 获取随机值
  14. int getRandom(void)
  15. {
  16.    return rand() % 100;
  17. }
  19. int main(void)
  20. {
  21.    int myarray[10];
  22.    populate_array(myarray, 10, getRandom); // getRandom 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针
  23.    for (int i = 0; i < 10; i++)
  24.    {
  25.       printf("%d ", myarray[i]);
  26.       // printf("%ld ", myarray[i]);
  27.    }
  28.    printf("\n");
  29.    return 0;
  30. }
  32. /* 
  33. 7 49 73 58 30 72 44 78 23 9  
  34. */

参数为long类型执行

  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <time.h>
  5. // 回调函数
  6. void populate_array(long *array, size_t arraySize, long (*getNextValue)(void))
  7. {
  8.    // srand((unsigned)time(NULL)); // 设置随机数种子，利用当前系统的系统
  9.    for (size_t i = 0; i < arraySize; i++)
  10.       array[i] = getNextValue();
  11. }
  13. // 获取随机值
  14. long getRandom(void)
  15. {
  16.    return rand() % 100;
  17. }
  19. int main(void)
  20. {
  21.    long myarray[10];
  22.    populate_array(myarray, 10, getRandom); // getRandom 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针
  23.    for (int i = 0; i < 10; i++)
  24.    {
  25.       //  printf("%d ", myarray[i]);
  26.       printf("%ld ", myarray[i]);
  27.    }
  28.    printf("\n");
  29.    return 0;
  30. }
  32. /* 
  33. 7 49 73 58 30 72 44 78 23 9  
  34. */

递归

递归指的是在函数的定义中使用函数自身的方法
递归函数在解决许多数学问题上起了至关重要的作用，比如计算一个数的阶乘、生成斐波那契数列，等等。

举个例子： 从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？ 从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？ 从前有座山，山里有座庙，庙里有个老和尚，正在给小和尚讲故事呢！故事是什么呢？……

语法格式如下：

  1. void recursion()
  2. {
  3.    recursion(); // 函数调用自身
  4. }
  6. int main()
  7. {
  8.    recursion();
  9. }

image.png
⚠️注意: C 语言支持递归，即一个函数可以调用其自身。但在使用递归时，程序员需要注意定义一个从函数退出的条件，否则会进入死循环。

数的阶乘

下面的实例使用递归函数计算一个给定的数的阶乘：

  1. #include <stdio.h>
  3. double factorial(unsigned int i)
  4. {
  5.    if (i <= 1)
  6.    {
  7.       return 1;
  8.    }
  9.    return i * factorial(i - 1);
  10. }
  11. int main()
  12. {
  13.    int i = 5;
  14.    printf("%d 的阶乘为 %f\n", i, factorial(i));
  15.    return 0;
  16. }
  18. /*
  19. 5 的阶乘为 120.000000
  20. */

斐波那契数列

下面的实例使用递归函数生成一个给定的数的斐波那契数列：

  1. #include <stdio.h>
  3. int fibonaci(int i)
  4. {
  5.    if (i == 0) { return 0; }
  6.    if (i == 1) { return 1; }
  7.    return fibonaci(i - 1) + fibonaci(i - 2);
  8. }
  10. int main()
  11. {
  12.    int i;
  13.    printf("%d\t\n", fibonaci(10));
  14.    return 0;
  15. }
  17. /*
  18. 144
  19. */