1. 函数是什么
数学中我们常见到函数的概念。
例如：y=f(x)
但是你了解C语言中的函数吗？
维基百科中对函数的定义：子程序
在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代 码，具备相对的独立性。
一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2. 库函数
为什么会有库函数？
- 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格
式打印到屏幕上（printf）。 - 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
- 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
那怎么学习库函数呢？
这里我们简单的看看：www.cplusplus.com
进入网站之后，我们该如何学习库函数呢？
我们看这里：
红色箭头标注的地方就是你搜索库函数的地方。
比如说我们搜索一个函数看看，输入strcpy，然后按回车：
我们来慢慢分析，黄色那里（）里面是你需要引用的头文件，不然你是用的不了的，就像你要用别人的东西要和那个人打招呼一样。记不记得我以前的参考代码经常有：
#include <stdio.h>
这个是打印函数printf函数的头文件。
红色圈圈里面是库函数的名字。
绿色圈圈里面是库函数的返回类型，参数。
紫色圈圈里面是对于库函数作用的解释
橙色圈圈里面是对于参数的解释
深红褐色圈圈里面是对于库函数的返回值的解释
蓝色圈圈是例子，下面是用一段代码举例
绿色圈圈里面是相关函数
对于这个函数我们了解如下：
char * strcpy ( char * destination, const char * source );
这是一个交换两个字符串的函数，我们看举的例子就知道，要把arr1数组里面的字符串放到arr2数组中，格式如此strcpy（arr2,arr1）。我们看到，参数的规定中，第二个是被const修饰过的，也就是说无法被修改，因为我们是要把arr1里面的内容拷贝到arr2中，并不需要改变arr1数组里面的内容，这个函数交换完之后还会返回一个char类型数值，至于有什么用，看你自己的了。
两个参数需要你传进去char类型的指针进去，数组名比如arr1其实是数组arr1首元素的地址，这个后面会详细讲解。
注：
但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。
这里对照文档来学习上面几个库函数，目的是掌握库函数的使用方法。
这里是学习库函数的网站：
www.cplusplus.com
http://en.cppreference.com（英文版）
http://zh.cppreference.com（中文版）
英文很重要。最起码得看懂文献
3. 自定义函数
如果库函数能干所有的事情，那还要程序员干什么？
所有更加重要的是自定义函数。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
函数的组成：
ret_type fun_name(para1, * ) { statement;//语句项 } ret_type 返回类型 fun_name 函数名 para1 函数参数
我们举一个例子：写一个函数可以找出两个整数中的最大值。
#include <stdio.h> //get_max函数的设计 int get_max(int x, int y) //参数为x和y，参数类型都是整形 { return (x>y)?(x):(y);//这里我们用到了一个三目操作符，先运算，然后返回这个结果 int main() { int num1 = 10; int num2 = 20; int max = get_max(num1, num2);//调用并且接收函数的返回值 printf("max = %d\n", max);//利用库函数printf打印 return 0; //这里是main函数的返回值 }
运行结果是：
20
return；是返回一个值，我们定义是，返回值为int类型。
这个返回时返回到那里呢？我们在哪里调用这个函数就是在哪里返回这个值，虽然它返回一个值，但是你不用一个相对应的类型变量接收或者是使用，那么这个返回的值也就没有被利用。我们这里接收的就是整型变量max。
我们先分析一下代码，进入main函数之后首先看到的是我创建了num1，num2这两个整型变量，这是我们需要区分大小的两个数。
然后就是我们声明了一个整型变量max拉接受自定义函数gat_max函数的值，函数后面有连个参数，参数之间用逗号隔开，这个参数是传给你自定义函数的内部然后使用，因为函数要实现的功能是找出两个数中最大的值，所以说要把比较的值传给我们的自定义函数，然后进入函数比较大小，这里的三目操作符就比较出了大小，结果就是20，然后return返回了20这个值，储存到了max这个整型变量，最后打印出来。
再举个例子：写一个函数可以交换两个整形变量的内容。
#include <stdio.h> void Swap1(int x, int y) //实现交换的自定义函数 { int tmp = 0; tmp = x; x = y; y = tmp; } int main() { int num1 = 1;//创建需要交换的两个变量 int num2 = 2; Swap1(num1, num2);//调用自定义函数Swap1 printf("Swap1::num1 = %d num2 = %d\n", num1, num2); return 0; }
运行结果是：
1 2
我们一看，诶？好像并没交换两个数值啊？
我们再来看一段代码：
void Swap2(int *px, int *py) //实现交换的自定义函数 { int tmp = 0; tmp = *px; *px = *py; *py = tmp; } int main() { int num1 = 1;//创建需要交换的两个变量 int num2 = 2; Swap2(&num1, &num2);//调用自定义函数Swap2，&符号之前说过是取地址符号 printf("Swap2::num1 = %d num2 = %d\n", num1, num2); return 0; }
这个的运行结果是：
2 1
这个自定义函数和上面的自定义函数又有什么区别呢？
我们知道，当你创建一个变量的时候系统已经默认给它分配了一块内存空间，也就是每个变量都有属于它自己的地址，第一段代码，变量num1和num2还有变量x和y都是局部变量，也就是说num1和num2又自己的地址，那么x和y也拥有自己的变量地址，它们的地址没有任何关系啊，都是独立的。
看红色圈圈的地方，我们这里用的功能是VS2022编译器的调试功能，以后我会出一篇调试的博客。这里我取出了x和y局部变量的地址，又取出了num1和num2的地址，对比发现，地址并不相同，但是里面的值是相同的，因为我们创建一个x和y的局部变量的时候在内存开辟了两块空间，空间里一开始是随机值，但是这里我们把num1和num2的值给传进去了，也就等于把赋值给了x和y。
这就是我们内存分布的情况。也就是说x和y只是num1和num2的临时拷贝而已。我们本质是要把num1和num2的值交换，可是进入函数之后我们交换的是x和y，这和num1和num2一点关系都没有，它们是不同的空间，也就是无法操控num1和num2。最后自定义函数也走到了尽头，局部变量的x和y也就自动销毁了，将这两块内存还给了操作系统。
我们来看第二个代码：
这里传给函数的参数是num1和num2的地址，函数接收使用一个指针变量来接收的，我们之前了解过，指针是储存地址的一个变量，这样我们就等于远程操控了num1和num2，因为可以通过地址从而找到它们的值进行操控。
看，num1和num2的地址与px和py指针变量是对应的。
之后，我们通过解引用这个操作符通过px和py的地址找到对应num1和num2的值利用tmp这个局部变量从而进行改变。
就像我们想把两个瓶子里面的液体交换需要第三个空瓶子一样。
也就是说这个自定义函数等于把num1和num2的值取出来之后互换一样，num1的值被放到了num2变量的内存里，num2的值被放到了num1的内存里。
4. 函数参数
4.1 实际参数（实参）
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
Swap1(int x, int y) 括号里面的两个就是实参，每个实参用逗号隔开
4.2 形式参数（形参）
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
上面 Swap1 和 Swap2 函数中的参数 x，y，px，py 都是形式参数。在main函数中传给 Swap1 的 num1 ，num2 和传给 Swap2 函数的 &num1 ，&num2 是实际参数。
例子就按照我们上面的Swap函数就可以了。
5. 函数的调用
5.1 传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
就像上面的Swap1自定义函数一样。
5.2 传址调用
- 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
- 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
就像上面的Swap2自定义函数一样。
6. 函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
6.1 嵌套调用
我们看这段代码：
#include <stdio.h> void new_line()//进入new_line自定义函数 { printf("hehe\n"); } void three_line()//进入three_line自定义函数 { int i = 0; for(i=0; i<3; i++) { new_line();//调用new_line自定义函数 } } int main() { three_line();//这里是调用three_line自定义函数 return 0; }
最终我们打印的结果是：
hehe
hehe
hehe
这就是嵌套调用。
虽然函数可以嵌套调用，但是不能嵌套定义。
看看这段代码的报错，他说这段代码需要在void new_line()后面加一个分号，如果加一个分号就等于在void new_line()后面直接结束了这个函数，这等于函数的声明（下面会讲），下面的代码块并没有运行，定义是和外面函数是一个级别的，不能谁嵌套谁的定义，但是可以嵌套调用。
6.2 链式访问
把一个函数的返回值作为另外一个函数的参数。
比如这个：
#include <stdio.h> #include <string.h> int main() { char arr[20] = "hello"; int ret = strlen(strcat(arr, "lol")); printf("%d\n", ret); return 0; }
我们首先来介绍两个库函数。
strcat
这个库函数上面有。
strlen
所以说我们strlen返回了字符串的长度被整型变量ret接收。最后再用printf打印出结果。
输出结果：8
我们再来看一段有趣的代码：
#include <stdio.h> int main() { printf("%d", printf("%d", printf("%d", 43))); //结果是啥？ //注：printf函数的返回值是打印在屏幕上字符的个数 return 0; }
printf(格式字符串，待打印项1，待打印项2…)
我们来分析，进入第一层printf函数时，看到一个参数，我们就知道要打印一个整形的数值，，第二个参数是什么？是第二层printf函数的返回值，于是编译器进入第二层查看，发现第二层printf函数的第一个参数也是打印一个整形数值，第二个参数是第三层的printf函数的返回值。
所以说首先执行的是第三层的printf函数，也就是打印43，它的返回值是2，2就是第二层printf函数的第二个参数，所以接下来打印了2这个整型数值，返回1，然后第一层的printf函数的第二个参数是1，所以打印1，返回一个1，但是我们最后一次返回的数值并没有任何变量接收，也没有被使用，所以说就不用管它。
我们最终的输出结果是：
4321
7. 函数的声明和定义
7.1 函数声明：
- 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
- 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
- 函数的声明一般要放在头文件中的。
我们初学者写代码的时候，只创建一个源文件来写，我们知道，一个工程中可以有多个源文件和头文件（源文件后面是.c头文件后面是.h）。
我们以后去公司的时候，不可能所有人都在同一个文件里写代码，而是分不同模块去写代码。这个以后我们再去感受。
比如我们要写一个加法函数去计算两个数值的和：
第一个是我们存在主函数的文件，也是创建你要算的值的变量和初始化，也是最后打印结果的地方。
第二个是我们计算加法的函数主体。
第三个是我们声明加法函数的头文件。
这就是分模块，其实我们发现，就算没有声明，编译器顶多就是一个警告，并不妨碍代码成功运行，那么我们的声明到底是什么作用的呢？其实这也是给人看的。
想象一下，假如说有一个人他不会实现加法这个代码，那么你会将代码通过变成静态库的手段，卖给别人，别人使用就会用到函数声明这个东西，我们这里不做过多的讲解。
函数是由外部链接属性的，虽然我们看它们不是一个文件里，但是我们在test.c这个源文件调取add这个函数时，他会到函数主体的地方去运行这个函数。我们还看到头文件里有一个是include "add.h"这是什么呢，就等于把你在add.h这个后文件里的声明给替换到test.c这个文件里include “add.h”这个地方。
7.2 函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。
函数定义我们说过了，函数名，比如add，add前面的是返回类型，括号里的是参数。
8. 函数递归
8.1 什么是递归？
程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小
8.2 递归的两个必要条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
- 每次递归调用之后越来越接近这个限制条件。
我们来用几道编程题来分析上面话的意义。
8.2.1练习：
接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234，输出 1 2 3 4.
我们来分析，输入不用说，输出怎么办呢？这里我们要一个一个打印。要把数一个一个拆开打印：
1234%10=4 拆下来4
1234/10=123 剩下123
123%10=3
123/10=12
12%10=2
12/10=1
1%10=1
1/10=0
用这种方式拆开，那么打印是先拆开的数，打印出来的就是：
4 3 2 1
那么我们就不能用之前的方式打印了，而是用递归的方式，参考代码如下：
#include <stdio.h> void print(int n) //我们自定义实现打印1 2 3 4数字的函数 { if(n>9) { print(n/10);//自己调用自己 } printf("%d ", n%10); } int main() { int num = 1234;//输入值 print(num);//第一次调用自定义函数 return 0; }
我们代码运行完之后，结果是：
1 2 3 4
我们来看看这段代码是如何运行的，首先从这里进入：
这是函数主体内部：
我们利用上面的逻辑，来把1234逐渐拆开。
这就是运行的思路，我们最后拆开的是1，然后是2 3 4，先运行的就是最后一层的函数，先打印的也就是1。
这里我们想一想，如果没有判断条件会怎么样呢？
那么就是自己会一直调用自己，导致栈溢出，程序崩溃，这里不做过多讲解。
8.3递归与迭代
虽然有些时候递归比迭代好用，可是有一些情况递归的方式并不好用。
比如说：
求第n个斐波那契数。（不考虑溢出）
参考代码：
int fib(int n) { if (n <= 2) return 1; else return fib(n - 1) + fib(n - 2);//计算斐波那契数 } int main() { int n; scanf("%d", &n); int ret = factorial(n); printf("%d", ret); return 0; }
我们输入10，输出是55。
但是我们输入40呢，50呢？
我们需要算多久？我们需要算多少个数呢？
在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
为什么呢？
我们发现 fib 函数在调用的过程中很多计算其实在一直重复。
我们算地40个斐波那契数就要算，第39个斐波那契数和38个斐波那契数相加，第39第个斐波那契数需要第38个斐波那契数和第37个斐波那契数相加，这就需要大量重复的数计算。
如果我们把代码修改一下：
int count = 0;//全局变量 int fib(int n) { if(n == 3)//如果进入函数等于3，count就+1一次 count++; if (n <= 2) return 1; else return fib(n - 1) + fib(n - 2); }
我们这里如果输入40，会发现count是一个很大的值。
那我们如何改进呢？
在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）这样的信息。
系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
那如何解决上述的问题：
- 将递归改写成非递归。
- 使用static对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
比如，下面代码就采用了，非递归的方式来实现：
#include <stdio.h> //求第n个斐波那契数 int fib(int n) { int result; int pre_result; int next_older_result; result = pre_result = 1; while (n > 2) { n -= 1; next_older_result = pre_result; pre_result = result; result = pre_result + next_older_result; } return result; } int main() { int n; scanf("%d", &n); int ret = fib(n); printf("%d", ret); return 0; }
这样就能算出来更大的斐波那契数了。
提示：
- 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
- 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
- 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开
销。
本篇结束
函数这一篇完结。
路过的大佬请指点不足和错误，家人们请点点赞，谢谢！
