其实函数在一开始就在使用了：
// 这就是定义函数
int main() {
...
}
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。
当然，除了主函数之外，一直在使用的printf也是一个函数，不过这个函数是标准库中已经实现好了的，这样就是在调用这个函数：
// 直接通过 函数名称(参数...) 的形式调用函数
printf("Hello World!");
那么，函数的具体定义是什么呢？
函数是完成特定任务的独立程序代码单元。
简单来说，函数是为了完成某件任务而生的，可能要完成某个任务并不是一行代码就可以搞定的，但是现在可能会遇到这种情况：
#include <stdio.h>
int main() {
int a = 10;
// 比如下面这三行代码就是要做的任务
printf("Hello");
printf("World");
printf("\n");
if(a > 5) {
// 这里还需要执行这个任务
printf("Hello");
printf("World");
printf("\n");
}
switch (a) {
case 10:
// 这里又要执行这个任务
printf("Hello");
printf("World");
printf("\n");
}
}
每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
这时就可以考虑使用函数了，可以将程序逻辑代码全部编写到函数中，当执行函数时，实际上执行的就是函数中的全部内容，也就是按照制定的规则执行对应的任务，每次需要做这个任务时，只需要调用函数即可。
创建和使用函数
首先来看看如何创建一个函数，其实创建一个函数是很简单的，格式如下：
返回值类型 函数名称([函数参数...]);
其中函数名称也是有要求的，并不是所有的字符都可以用作函数名称，它的命名规则与变量的命名规则基本一致，这里就不一一列出了。
函数不仅仅需要完成任务，某些函数还需要返回结果，此时就需要定义返回值，并在函数中返回这一结果；当然如果函数只需要完成任务，不需要返回结果，返回值类型可以写成void表示空。
#include <stdio.h>
// 定义函数原型，因为C语言是从上往下的，所以如果要在下面的主函数中使用这个函数，一定要定义到它的上面。
void test(void);
int main() {
// 调用函数
test();
}
// 函数具体定义，添加一个花括号并在其中编写程序代码，就和之前在main中编写一样
void test(void) {
printf("我是测试函数");
}
我是测试函数
这样，就可以很好解决代码复用性的问题。只需要将会重复使用的逻辑代码定义到函数中，当需要执行时，直接调用编写好的函数就可以了，这样就简单很多了。
#include <stdio.h>
void test(int a) {
printf("Hello");
printf("World");
printf("\n");
}
int main() {
int a = 10;
test(a);
if(a > 5) test(a);
switch (a) {
case 10:
test(a);
}
}
HelloWorld
HelloWorld
HelloWorld
当然函数除了可以实现代码的复用之外，也可以优化程序，让代码写得更有层次感，一个程序可能会有很多很多的功能，需要写很多的代码，但是谁愿意去看一个几百行上千行的main函数呢？可以将每个功能都写到一个对应的函数中，这样就可以大大减少main函数中的代码量了。
int main() {
func1();
func2();
func3();
}
而从一开始就在编写的 main 函数实际上是一种比较特殊的函数，C 语言规定程序一律从主函数开始执行，所以这也是为什么一定要写成int main()的形式。
全局变量和局部变量
现在已经了解了如何创建和调用函数，在继续学习后续内容之前，我们需要先认识一下全局变量和局部变量这两个概念。
首先来看看局部变量，实际上之前使用的都是局部变量，比如：
int main() {
// 这里定义的变量i实际上是main函数中的局部变量，它的作用域只能是main函数中，也就是说其他地方是无法使用的
int i = 10;
}
所以下面这种写法是完全没问题的：
int main() {
for (int i = 0; i < 10; ++i) {
}
for (int i = 0; i < 20; ++i) {
}
}
虽然这里写了两个 for 都使用了 i，但是由于处于两个不同的作用域，所以互不影响
那么如果现在想要在任何位置都能使用一个变量，该怎么办呢？这时就要用到全局变量了：
#include <stdio.h>
void test();
// 可以直接将变量定义放在外面，这样所有的函数都可以访问了
int a = 10;
int main() {
a += 10;
test();
printf("%d", a);
}
void test() {
a += 10;
}
30
因为现在所有函数都能使用全局变量，所以这个结果不难得到。
函数参数和返回
函数可以接受参数来完成任务，比如现在想要实现用一个函数计算两个数的和并输出到控制台。
这种情况就需要将进行加法计算的两个数，告诉函数，这样函数才能对这两个数求和，那么怎么才能告诉函数呢？可以通过设定参数：
#include <stdio.h>
// 函数原型中需要写上需要的参数类型，多个参数用逗号隔开，比如这里需要的就是两个int类型的参数
void test(int, int);
int main() {
// 这里直接填写一个常量、变量或是运算表达式都是可以的，一般称实际传入的值为实际参数（实参）
test(10, 20);
}
// 函数具体定义中也要写上，这里的a和b称为形式参数（形参），等价于函数中的局部变量，作用域仅限此函数
void test(int a, int b) {
printf("%d", a + b);
}
30
实际上传入的实参在进入到函数时，会自动给函数中形参（局部变量）进行赋值，这样在函数中就可以得到外部传入的参数值了。
来看看printf函数是怎么写的：
int printf(const char * __restrict, ...) __printflike(1, 2);
这里主要关心它的两个参数：
- 第一个参数是
char *（由于还没有学习指针，这里就把它当做const char[]就行了），表示一个不可修改的字符串 - 第二个参数是
...，这三个点是个啥？
如果想要填写具体需要打印的值时，可以一直往后写：
printf("%d, %d", 1, 2);
正常情况下函数的参数列表都是固定的，怎么才能像这样写很多个呢？
这就要用到可变长参数了，不过可变长参数的使用比较麻烦，这里就不做讲解了。
如果修改形式参数的值，外面的实参值会跟着发生修改吗？
#include <stdio.h>
void swap(int, int);
int main() {
int a = 10, b = 20;
swap(a, b);
printf("a = %d, b = %d", a, b);
}
void swap(int a, int b) {
// 这里对a和b的值进行交换
int tmp = a;
a = b;
b = tmp;
}
a = 10, b = 20
通过结果发现，虽然调用了函数对 a 和 b 的值进行交换，但并没有什么影响。这是为什么呢？
还记得前面说的吗，函数的形参实际上就是函数内的局部变量，它的作用域仅仅是这个函数，而外面传入的实参，仅仅只是将值赋值给了函数内的形参而已，并且外部的变量跟函数内部的变量作用域都不同，这里交换的仅仅是函数内部的两个形参变量值，跟外部作实参的变量没有任何关系。
那么，怎么样才能实现通过函数交换两个变量的值呢？这个问题会在指针部分进行讨论。
不过数组却不受限制，我们在函数中修改数组的值，是直接可以生效的：
#include <stdio.h>
void test(int arr[]);
int main() {
int arr[] = {4, 3, 8, 2, 1, 7, 5, 6, 9, 0};
test(arr);
printf("%d", arr[0]);
}
void test(int arr[]) {
// 数组就可以做到里面修改，外面生效
arr[0] = 999;
}
999
如果就是希望每次调用函数时保留变量的值，可以使用静态变量：
#include <stdio.h>
void test();
int main() {
test();
test();
}
void test() {
// 静态变量会在函数创建时就定义，后续不会再定义，且不会在函数结束时销毁其值
static int a = 20;
a += 20;
printf("%d ", a);
}
40 60
接着来看函数的返回值，并不是所有的函数都是执行完毕就结束了的，可能某些时候需要函数告诉我们执行的结果如何，这时就需要用到返回值了，比如现在希望实现一个函数计算 a + b 的值：
#include <stdio.h>
// 现在要返回a和b的和，因为参数都是int，所以这里需要将返回值类型也设定为int
int sum(int ,int);
int main() {
// 计算a和b的和
int a = 10, b = 20;
// 函数执行后，会返回一个int类型的结果，可以接收它，也可以像下面一样直接打印，也可以参与运算
int result = sum(a, b);
printf("a+b=%d", sum(a, b));
}
int sum(int a, int b) {
// 通过return关键字来返回计算的结果
return a + b;
}
a+b=30
接着来看下一个例子，现在希望通过函数找到数组中第一个小于 0 的数字并将其返回，如果没有找到任何小于 0 的数，就返回 0：
#include <stdio.h>
// 需要两个参数，一个是数组本身，还有一个是数组的长度
int findMin(int arr[], int len);
int main() {
int arr[] = {1, 4, -9, 2, -4, 7};
int min = findMin(arr, 6);
printf("第一个小于0的数是：%d", min);
}
int findMin(int arr[], int len) {
for (int i = 0; i < len; ++i) {
// 当判断找到后，直接return返回即可，这样的话函数会直接返回结果，无论后面还有没有代码没有执行完，整个函数都会直接结束。
if (arr[i] < 0) {
return arr[i];
}
}
// 如果没有找到就返回0
return 0;
}
第一个小于0的数是：-9
这里使用了return关键字来返回结果，注意当程序走到return时，无论还有什么内容没执行完，整个函数都将结束，并返回结果。
带返回值（非void）的函数中都需要有一个对应的返回值：
int test(int a) {
if (a > 0) {
// 当a大于0时有返回语句
return 10;
} else{
// 但是当a不大于0时就没有返回值了，这样虽然可以编译通过，但是会有警告（黄标），运行后可能会出现一些无法预知的问题
}
}
如果是没有返回值的函数，也可以调用return来返回，如果在函数结束之前返回，代表提前结束函数；如果在函数末尾返回，就代表函数正常结束（默认情况下是可以省略的）
void test(int a){
if(a == 10) return; //因为是void，所以什么都不需要加，直接return
printf("%d", a);
}
递归调用
函数除了在其他地方被调用之外，也可以自己调用自己，这种方式称为递归。
#include <stdio.h>
void test(){
printf("Hello World!\n");
// 函数自己在调用自己，这样的话下一轮又会进入到这个函数中
test();
}
int main() {
test();
}
如果运行上面的程序，会发现程序直接无限打印Hello World!这个字符串，这是因为函数自己在调用自己，不断地重复进入到这个函数。理论情况下，它将永远都不会结束，而是无限地执行这个函数的内容。
但是到最后程序还是终止了，这是因为函数调用有最大的深度限制，因为计算机不可能放任函数无限地进行下去。
（选学）大致了解一下函数的调用过程，实际上在程序运行时会有一个叫做函数调用栈的东西，它用于控制函数的调用。
以下面的程序为例：
#include <stdio.h>
void test2(){
printf("调用test2");
}
void test(){
test2();
printf("调用test");
}
int main() {
test();
printf("调用main");
}
其实可以很轻易地看出整个调用关系，首先是从 main 函数进入，然后调用 test 函数，在test函数中又调用了 test2 函数，此时就需要等待 test2 函数执行完毕，test 才能继续，而 main 则需要等待 test 执行完毕才能继续。而实际上这个过程是由函数调用栈在控制的：
而当 test2 函数执行完毕后，每个栈帧又依次从栈中出去：
当所有的栈全部出去之后，程序结束。
所以这也就不难解释为什么无限递归会导致程序出现错误，因为栈的空间有限，而函数又一直在进行自我调用，所以会导致不断地有新的栈帧进入，最后塞满整个栈的空间，就爆炸了，这种问题称为栈溢出（Stack Overflow）
当然，如果按照规范使用递归操作，是非常方便的，比如现在需要求某个数的阶乘：
#include <stdio.h>
int test(int n);
int main() {
printf("%d", test(3));
}
int test(int n) {
// 因为不能无限制递归下去，所以我们这里添加一个结束条件，在n = 1时返回
if (n == 1) {
return 1;
}
// 每次都让n乘以其下一级的计算结果，下一级就是n-1了
return test(n - 1) * n;
}
6
通过给递归调用适当地添加结束条件，这样就不会无限循环了，并且程序看起来无比简洁，那么它是如何执行的呢：
它看起来就像是一个先走到底部，然后拿到问题的钥匙后逐步返回的一个过程，并在返回的途中不断进行计算最后得到结果。
所以，合理地使用递归反而是一件很有意思的事情。
实战：斐波那契数列解法其三
前面介绍了函数的递归调用，来看一个具体的实例吧，还是以解斐波那契数列为例。
既然每个数都是前两个数之和，那么是否也可以通过递归的形式不断划分进行计算呢？依然可以借鉴之前动态规划的思想，通过划分子问题，分而治之来完成计算。
#include <stdio.h>
int fib(int n) {
if (n == 1 || n == 2) {
return 1;
}
return fib(n - 1) + fib(n - 2);
}
int main() {
printf("%d", fib(7));
}
13