目录
1. 函数的概念
数学中也有函数的概念，⽐如：⼀次函数 y=kx+b ，k和b都是常数，给⼀个任意的x，就得到⼀个y值。
C 语言也引入函数（function）的概念，有些也翻译为子程序。C 语言中的函数就是一个完成某项特定任务的一小段代码。这段代码有特殊的写法和调用的方法。
C语⾔的程序其实是由⽆数个⼩的函数组合⽽成的，也可以说：⼀个⼤的计算任务可以分解成若⼲个较⼩的函数（对应较⼩的任务）完成。同时⼀个函数如果能完成某项特定任务的话，这个函数也是可以复⽤的，提升了开发软件的效率。
在 C 语言中一般有两种函数：（1）库函数（2）自定义函数。
2. 库函数
2.1 标准库
C 语言标准中规定了 C 语言的各种语法规则，C 语言并不提供库函数，C 语言的国际标准 ANSI C 规定了一些常用的函数的标准，被称为标准库，不同的编译器根据 ANSI 提供的 C 语言标准就给出一系列函数的实现，这些函数就被称为库函数。
printf、scanf 都是库函数，库函数也是函数，不过这些函数已经是现成的，是 C 语言标准库中的函数，各种编译器的标准库提供一系列的库函数，这些库函数根据功能的划分，都在不同的头文件中进行声明，我们包含对应头文件就可以直接使用了。
C 语言标准库相关头文件可以参考：https://en.cppreference.com/w/c/header.html
2.2 头文件包含
库函数是在标准库中对应的头文件中声明的，所以库函数的使用必须包含对应的头文件，不包含可能会出现一些问题。
//#include <stdio.h>
int main()
{
double d = 16.0;
printf("%lf\n", d);
return 0;
}
如上图，当不包含头文件 stdio.h 时，程序运行时会无法解析符号 printf，也就是找不到对应的 printf 函数。
3. 自定义函数
标准库函数毕竟不能解决所有的问题，当需要实现一些特定的功能的时候，就需要程序员自己进行函数的实现。所以不是标准库中的库函数，都是其他程序员进行实现的，也叫做自定义函数。
3.1 函数的语法形式
ret_type fun_name(形式参数)
{
}ret_type：表示函数返回的数据类型，返回类型如果为 void，表示什么都不返回。
fun_name：函数名，调用该函数的时候使用函数名进行调用，尽量根据函数功能起有意义的名称。
形式参数：声明函数需要传递的参数类型，可以是 0 个（void）也可以是多个，如果有参数，要交代清楚参数的类型和名字，以及参数的个数。
{}：大括号括起来的就是函数体，也就是函数的执行过程。
可以把函数想象成⼩型的⼀个加⼯⼚，⼯⼚得输⼊原材料，经过⼯⼚加⼯才能⽣产出产品，那函数也是⼀样的，函数⼀般会输⼊⼀些值（可以是0个，也可以是多个），经过函数内的计算，得出结果。
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);
int r = Add(a, b);
//输出
printf("%d\n", r);
return 0;
}
如上图，自定义实现一个 Add 函数，实现两个整数的相加，其中 int 为该函数返回的数据类型，int x，int y 为该函数两个参数的类型和名字，Add 为函数名。
3.2 形参和实参
函数使用的过程中，把函数的参数分为实参和形参。在上述函数中，5 ~ 10 行为 Add 函数的定义，19 行为函数的调用。
在函数调用的时候，传入的参数 a，b 就叫做实际参数，简称实参。
在函数声明或者定义的时候，函数名后括号中的 x，y就叫做形式参数，简称形参。实际上，如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x 和 y 只是形式上存在的，不会向内存申请空间，不会真实存在的，所以叫形式参数。只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，这个过程就是形式的实例化。
3.3 实参和形参的关系
虽然实参是传递给形参的，但是形参和实参各自是独立的内存空间。
#include <stdio.h>
int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);
//调⽤加法函数，完成a和b的相加
//求和的结果放在r中
int r = Add(a, b);
//输出
printf("%d\n", r);
return 0;
}
在调试的过程中可以看到，a，b 变量的地址和 x，y 变量的地址是不一样的，所以我们可以理解为形参是实参的一份临时拷贝，在函数调用结束之后，形参所占用的空间就会自动被释放。
4. return 语句
（1）return 后面可以是一个数值，也可以是一个表达式，如果是表达式则先执行表达式，再返回表达式的结果。
（2）return 后面可以什么都没有，直接写 " return; "。这种写法适合返回类型为 void 的情况。
（3）return 返回的值和函数返回类型不一致，有些类型系统会进行隐式转换，转换为函数的返回类型，比如 short 转成 int 等，但是每个类型的大小不一样，从 int 转成 short 会把高 16 位的数据进行截断。
（4）return 语句执行后，函数就彻底返回，后面的代码不再执行。
（5）如果函数中存在 if 等分支语句，则要保证每种情况下都有 return 返回，否则会编译报错。
5. 数组做函数参数
写一个函数 set_arr 用于将函数中的数值全部置为 -1，并写一个函数 print_arr 打印函数中的所有元素。
#include <stdio.h>
void set_arr(int arr[], int sz)
{
for (int i = 0; i < sz; i++)
arr[i] = -1;
return;
}
void print_arr(int arr[], int sz)
{
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return;
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int sz = sizeof(arr) / sizeof(arr[0]);
set_arr(arr, sz);
print_arr(arr, sz);
return 0;
}
数组也是一种数据类型，如上述代码中，函数的参数 int arr[] 就是数组类型。
（1）数组传参时形参并不是实参的拷贝，形参不会创建新的数组，所以函数中操作形参的数组和实参的数组是同一个数组。
（2）形参如果是一维数组，数组的大小可以省略不写。
（3）形参如果是二维数组，行可以省略，列不能省略。
6. 嵌套调用和链式访问
6.1 嵌套调用
嵌套调用就是在某一个函数中调用另一个函数（或本函数），上述的例子中，在 printf_arr 函数中调用了 printf 库函数，也是一种嵌套调用。
假设我们计算某年某⽉有多少天？如果要函数实现，可以设计2个函数:
（1）is_leap_year()：根据年份确定是否是闰年。
（2）get_day_of_month()：调用 is_leap_year 确定是否是闰年后，再根据月份计算这个月的天数。
#include <stdio.h>
int is_leap_year(int y) // 闰年返回 1，非闰年返回 0
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
return 1;
else
return 0;
}
int get_days_of_month(int y, int m)
{
// 从下标为 1 的位置往后，为 1-12 月的天数
int days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
int day = days[m];
if (is_leap_year(y) && m == 2)
day += 1;
return day;
}
int main()
{
int y = 0;
int m = 0;
scanf("%d %d", &y, &m);
int d = get_days_of_month(y, m);
printf("%d\n", d);
return 0;
}
上述代码中，mian 函数中嵌套调用 scanf、printf 以及 get_days_of_month 函数，get_days_of_month 中嵌套调用 is_leap_year 函数。
函数之间可以嵌套调用，但是不能嵌套定义。
6.2 链式访问
链式访问就是将一个函数的返回值作为另一个函数的参数，像链条一样将函数串起来。
#include <stdio.h>
int main()
{
int len = strlen("abcdef"); //1.strlen求⼀个字符串的⻓度
printf("%d\n", len); //2.打印⻓度
return 0;
}上述代码中用两条语句完成了打印一个字符串长度的功能，将 strlen 的返回值直接作为 printf 函数的参数，这样就是链式访问了。
#include <stdio.h>
int main()
{
printf("%d\n", strlen("abcdef"));
return 0;
}看一个有趣的代码：
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}要想知道该语句执行的结果是什么，就需要知道 printf 函数的返回值是什么。
int printf ( const char * format, ... );printf 函数的返回值为打印在屏幕上的字符个数。
所以第一个 printf 在屏幕上打印 " 43 " 两个字符，所以返回值为 2，则第二个printf 在屏幕上打印 " 2 " 一个字符，返回值为 1，最后一个 printf 在屏幕上打印 " 1 " 一个字符，该 printf 返回值没有其他函数接收，所以最终在屏幕上打印的结果为 " 4321 "。
7. 函数的声明和定义
7.1 单个文件
之前在使用函数的时候，直接将函数的定义写出来就能在 main 函数中进行调用了。
如上图，红色部分为函数的定义，绿色部分为函数的调用，这种函数的定义在函数调用之前是没有问题的。
如果将函数的定义放在函数的调用之后，编译器就会有如下警告信息：
这是因为 C 语言编译器对源代码进行编译的时候，从第一行往下扫描，当遇到 is_leap_year 函数调用时，并没有发现前面有 is_leap_year 函数的定义，就会有如上警告。
为了解决上述问题，可以在 is_leap_year 函数调用之前先声明 is_leap_year 函数，告诉编译器有这个函数，声明时要交代清楚函数名、函数的返回类型以及函数的参数。
函数的调用一定要满足先声明后使用，函数的定义也是一种特殊的声明，如果函数定义放在函数调用之前就可以不用在额外声明了。
7.2 多个文件
在项目中，代码可能比较多，不会将所有的代码都放在一个文件中，往往会根据程序的功能，将代码拆分放在多个文件中。
一般情况，函数的声明、类型的声明放在头文件（.h 文件）中，函数的实现放在源文件（.c 文件）中。
// add.h
//函数的声明
int Add(int x, int y);// add.c
//函数的定义
int Add(int x, int y)
{
return x + y;
}// test.c
#include <stdio.h>
#include "add.h"
int main()
{
int a = 10;
int b = 20;
//函数调⽤
int c = Add(a, b);
printf("%d\n", c);
return 0;
}
如上所示，将函数 Add 的声明放在 add.h 头文件中，Add 的定义放在 add.c 源文件中，在 test.c 文件中包含 add.h 头文件就可以调用 Add 函数了。
7.3 static 和 extern
static 和 extern 都是 C 语言中的关键字，static 是静态的意思，可以用于修饰局部变量、全局变量以及函数。
extern 是用来声明外部符号的。
7.3.1 作用域和生命周期
作用域（scope）：是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
（1）局部变量的作用域是变量所在的局部范围。
（2）全局变量的作用域是整个工程（项目）。
生命周期：指的是变量的创建（申请内存）到变量的销毁（回收内存）之间的一个时间段。
（1）局部变量的生命周期：进程作用域变量创建，生命周期开始，出作用域生命周期结束。
（2）全局变量的生命周期：整个程序从创建到结束。
#include <stdio.h>
int global = 10;
int main()
{
int arr[] = { 1,2,3,4,5 };
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
printf("arr[%d] = %d, 全局变量 global = %d\n", i, arr[i], global);
}
printf("%d\n", global);
return 0;
}
如上所示，全局变量 global 的作用域是整个工程，生命周期从程序开始到结束，所以在整个代码的任何地方都可以调用该变量。 局部变量 i 的生命周期和作用域只在 for 循环内部，所以在 for 循环外部是不能在使用局部变量 i 的。
7.3.2 static 修饰局部变量
//代码1
#include <stdio.h>
void test()
{
int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}
//代码2
#include <stdio.h>
void test()
{
//static修饰局部变量
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}
如上所示，对比代码 1 和代码 2 的运行结果，使用 static 修饰局部变量之后，运行结果是不一样的。
代码 1 的 test 函数中的局部变量 i 每次进入 test 函数都会重新创建 i 变量并赋值为 0，然后 i++ 后进行打印，出 test 函数后 i 变量生命周期结束（释放内存），下次再调用时重新创建 i 变量并赋值为 0。
代码 2 中，test 函数中 static 修饰的 i 变量创建好之后，出函数的时候是不会销毁的，重新进入函数也就不会重新创建 i 变量，直接使用之前的 i 变量。
static 修饰局部的变量生命周期被改变，生命周期改变的本质是改变了变量的存储类型，本来一个局部变量是存储在内存的栈区，但是被 static 修饰后存储到了静态区。存储在静态区的变量和全局变量的生命周期一样，但是使用 static 修饰的局部变量作用域不变，在 test 函数外还是不能调用变量 i。
static 修饰局部变量会延长局部变量的生命周期，不改变局部变量的作用域。
一个变量出了函数后还需要保留值，等下次进入函数后继续使用，就可以使用 static 修饰。
7.3.3 static 修饰全局变量
// 代码1
// add.c
int g_val = 2018;
// test.c
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
extern 是用来声明外部符号的，如果一个全局的符号在 A 文件中定义了，想要在 B 文件中使用，就可以使用 extern 在 B 文件中对 A 文件中的全局符号进行声明，然后进行使用。
如上述代码，在 add.c 文件中定义的全局变量 g_val，在 test.c 文件中使用 extern 关键字进行声明，则可以在 test.c 文件中使用 add.c 文件中的全局变量 g_val。
// 代码2
// add.c
static int g_val = 2018;
// test.c
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
如上图，使用 static 修饰 add.c 文件中的全局变量 g_val 时，在 test.c 中进行调用，会出现链接性错误。
static 修饰的全局变量，该全局变量只能在本源文件内使用，不能再其他源文件内使用。本质原因是全局变量默认具有外部链接属性，在外部的文件中想使用只需要声明即可，但是全部变量被 static 修饰之后，外部链接属性就变成了内部链接属性，就算其他源文件声明了，也不能使用。
static 修饰全局变量不改变全局变量的生命周期，但是会将全局变量的外部链接属性修改为内部链接属性。
7.3.4 static 修饰函数
static 修饰函数和 static 修饰全局变量一模一样，没有被 static 修饰的函数，在整个工程都可以使用，被 static 修饰的函数只能在本源文件中使用。
本质是因为函数默认具有外部链接属性，但是被 static 修饰后变成了内部链接属性，使得函数只能在自己所在的源文件内部使用。
static 修饰函数会将函数的外部链接属性修改为内部链接属性。
8. 函数递归
8.1 递归函数的介绍
在 C 语言中，函数自己调用自己就叫做函数递归。
#include <stdio.h>
int main()
{
printf("%d\n", 1);
main();
return 0;
}上述就是一个简单的递归程序，在 main 函数中调用 main 函数，该代码是一个死循环，会一直打印 1，最终会导致栈溢出（Stack overflow）。
把一个大型复杂问题层次转化为一个与原问题相似，但是规模较小的子文件来求解，直到子问题不饿能再被拆分，然后将子问题的返回结果依次往上返回，就是递归的思想。
递归中的递就是将问题一直分解成规模较小的子问题，归就是从最小规模的子问题返回，回归到最终的原问题上。
递归函数在编写的时候有两个必要条件：（1）递归存在限制条件，当满足该限制条件时，递归函数便不在分解子问题。（2）每次递归调用后越来越接近限制条件。
8.2 递归函数的例子
例1：求 n 的阶乘。
n 的阶乘公式为 n! = n * (n - 1)!，当 n == 0 时，n 的阶乘为 1，那么 n 的阶乘的递归公式如下：
#include <stdio.h>
int Fact(int n)
{
if (n == 0)
return 1;
else
return n * Fact(n - 1);
}
int main()
{
int n = 0;
scanf("%d", &n);
printf("%d\n", Fact(n));
return 0;
}
上述代码就如上述递归图一样，从 n = 5 一直往下递推，当 n = 0 时满足限制条件，返回 1，然后依次向上回归。
8.3 递归与迭代
如上述例子，Fact 函数是可以产生正确的结果，但是在递归函数调用的过程中涉及一些运行时的开销。
在 C 语言每次函数调用时，都需要为本次函数调用在栈区申请一块内存空间来保存函数调用期间的各种局部变量的值，这块空间被称为运行时堆栈，或者函数栈帧。
函数不返回，函数对应的栈帧空间就一直占用，所以如果函数调用中存在递归调用的话，每次递归函数调用都会开辟属于自己的栈帧空间，直到函数递归不再继续，开始回归时才逐层释放栈帧空间。
如果采用函数递归的方式完成代码，递归层次太深，就会浪费太多的栈空间，也可能引起栈溢出问题。
那么为了避免递归引起的栈溢出问题，通常使用迭代的方式代替递归，迭代的方式也就是循环的方式。
就比如上述计算 n 的阶乘，也就是 1 ~ n 的数字累积相乘，代码的编写可以如下：
int Fact(int n)
{
int ret = 1;
for (int i = 1; i <= n; i++)
ret *= i;
return ret;
}许多问题以递归的形式进行解释，只是因为它比非递归的形式更加清晰，但是这些问题的迭代实现往往比递归实现效率高。
扫一扫
900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
