函数声明，递归，回调，内联函数

一、函数的声明。
1、函数的定义与函数的声明有什么区别？
函数定义： 包含了函数名字，形参，返回值类型，函数实现过程。
int add_fun(int x,int y)
{
    return x+y;
}

函数声明： 包含了函数名字，形参，返回值类型
int add_fun(int x,int y);

2、什么时候需要进行函数声明？
1）如果函数的定义写在函数调用之前，那么就不需要声明该函数了。

int add_fun()  -> 函数定义
{

}

int main()
{
    add_fun();  -> 函数调用
}

2）如果函数的定义写在main函数的后面，那么就要声明。

--------------------------------------------
int main()
{
    add_fun();  -> 函数调用
}

int add_fun()  -> 函数定义
{

}
---------------------------------------------
如果这样进行编译，就会警告，说add_fun没有声明。
解决方案：在调用之前，进行声明。

--------------------------------------------
int add_fun();  -> 函数声明
int main()
{
    add_fun();  -> 函数调用
}

int add_fun()  -> 函数定义
{

}
---------------------------------------------

二、从内存角度分析函数调用过程。

int my_fun(int c)
{
    c = c/5;
    return c;
}

int fun(int a,int b)
{
    int c;     //c的生命周期从这里开始
    c = a + b;
    my_fun(c);
    return c;  //c的生命周期从这里结束
}

int main(int argc,char *argv[])
{
    int a = 10,b = 5;
    int ret = fun(a,b);
    printf("ret = %d\n",ret); //15
    return 0; //main函数返回代表程序结束，所以k的生命周期在这里结束。
}

结论1：局部变量在栈区申请，全局变量在bss/data区申请。
结论2：形式参数也是属于局部变量，所以说也要在栈区申请空间。
结论3：形式参数的值是由实际参数直接初始化。
结论4：是return语句执行完之后，函数的空间才会释放。
结论5：函数的返回值会返回到函数调用的地方。
结论6：函数返回之后，该函数里面申请的所有局部变量的空间都要释放。

三、递归函数。
1、什么是递归函数？
递归函数与函数嵌套非常相似。
函数嵌套就是在自定义函数A中调用自定义函数B。
递归函数就是在自定义函数A中调用自定义函数A。

简单地说，递归函数就是自己调用自己，函数嵌套就是自己调用别人。

函数嵌套：
int funB()
{
    ...;
}

int funA()
{
    ...;
    funB();
    ...;
}

int main(int argc,char *argv[])
{
    ....;
    funA();
    ....;
}

递归函数：
int funA()
{
    ....;
    funA();
}

int main(int argc,char *argv[])
{
    fun(A);
}

2、递归函数特点？
递归函数由于自己调用自己，造成无限递归，没有终止时刻。  -> 思考： 这样会导致什么？

例子：以下程序在内存中如何变化的？
void fun()
{
    int a;  -> 在栈区中连续申请4个字节，使用变量a间接访问这片内存空间。
    fun();
}

int main(int argc,char *argv[])
{
    fun();
}

结论：如果递归没有终止条件，那么就会造成栈溢出，所以在一般情况，我们都会给递归函数添加一个终止条件。
      也就是说，到达某一个瞬间，不要再调用自己。

四、递归函数题型。
题型1： 给程序，求结果。
请问以下的程序的结果是多少？

void fun(int n)
{
    if(n > 1)
    {
        fun(n-1);
    }
    printf("n = %d\n",n);
    return;
}

int main(int argc,char *argv[])
{
    fun(100);
    return 0;
}

结果：1~100

解题思路：
1）找到终止条件  n=1
什么是终止条件？
在什么情况下，不再调用自己。

2）列出前面几项与靠近终止条件的几项，观察规律。
3）画图分析，得到答案。

题型2： 给规律，写程序。
请写出以下的程序：
有5个学生坐在一起，问第5个学生多少岁，他说比第4个学生大2岁，问第4个学生多少岁，他说比第3个学生大2岁，问第3个学生多少岁，他说比第2个学生大2岁，问第2个学生多少岁，他说比第1个学生大2岁，我问第1个学生多少岁，他说是10岁。请问第5个学生多少岁？要求使用递归函数来完成。

解题思路：
1）找到终止条件。   -> get_age(1)就是10岁。
2）找到最终目标与终止条件之间的关系。   -> get_age(5)与get_age(1)有什么关系？

   get_age(5) = get_age(4) + 2;
   get_age(4) = get_age(3) + 2;
   get_age(3) = get_age(2) + 2;
   get_age(2) = get_age(1) + 2;
   get_age(1) = 10;

3）根据关系，求出通项公式。
   get_age(x) = get_age(x-1) + 2;

4）根据关系，代入模板。
int get_age(xxxx)
{
    /* 1. 错误判断 */

    /* 2. 终止条件 */

    /* 3. 通项公式 */
}

例子：
#include <stdio.h>

int get_age(int n) //n就是第几个学生
{
    int age;
    /* 错误判断 */
    if(n<=0)
        return -1;
    
    /* 终止条件 */
    if(n==1)
        age = 10;
    
    /* 通项公式 */
    if(n>1)
        age = get_age(n-1) + 2;
    
    return age;
}

int main(int argc,char *argv[])
{
    int x,ret;
    scanf("%d",&x);
    ret = get_age(x);
    printf("ret = %d\n",ret);//18
    
    return 0;
}

    练习1： 画出以上程序的内存变化图。  -> 抓住7个结论。
    练习2： 有以下程序，求结果。 //53

int fun(int n)
{
    if(n == 1)
        return -1;
    else
        return (n + fun(n-1));

}

int main(int argc,char *argv[])
{
    int x;
    scanf("%d",&x); //10
    x = fun(x);
    printf("x = %d\n",x);
    return 0;
}

   练习3：第一天存100元，后面每一天都比昨天多存10元，请问第312天当天存了多少钱？
    
1）终止条件  -> get_money(1)  -> 100
2）找到最终目标与终止条件关系。

   get_money(312) = get_money(311) + 10;
   get_money(311) = get_money(310) + 10;
   get_money(310) = get_money(309) + 10;
   ....
 
   get_money(2) = get_money(1) + 10;
   get_money(1) = 100

3）求通项公式。
   get_money(n) = get_money(n-1) + 10;

4）代入模板。
#include <stdio.h>

int get_money(int n)
{
    int money;
    /* 错误判断 */
    if(n <= 0)
        return -1;
    
    /* 终止条件 */
    if(n == 1)
        money = 100;
    
    /* 通项公式 */
    if(n > 1)
        money = get_money(n-1) + 10;
    
    return money;
}

int main(int argc,char *argv[])
{
    int x,ret;
    scanf("%d",&x);
    ret = get_money(x);
    printf("ret = %d\n",ret);
    
    return 0;
}

五、回调函数。
1、什么是回调函数？
先定义好函数A(买水，喝水的过程)，再将这个函数A(买水，喝水的过程)作为另外一个函数B(爬山)的参数，然后在函数B(爬山)执行过程中回过头来调用函数B的参数(函数A),这个函数A就称之为回调函数。

2、回调函数基本框架。

int funB(funA)
{
    ...;
    /* 执行过程中 */
    funA

}

int funA()  -> 先定义好函数A的实现过程
{
    /* 喝水的过程 */
}

int main()
{
    funB(funA);
}

3、回调函数核心：先写好你的功能函数，然后将这个功能函数作为另外一个函数的参数。

    例题：从键盘中获取两个数字，求出两个值的和。要求使用回调函数来完成。

1）通过分析，求和功能作为回调函数。
int add_fun(int x,int y)
{
    return x+y;
}

2）在main函数中调用函数，把回调函数作为该函数的参数，进行求和。
int main(int argc,char *argv[])
{
    int a,b,ret;
    scanf("%d %d",&a,&b);

    ret = my_fun(a,b,add_fun);  -> 直接写函数的名字就是传递参数。
    printf("ret = %d\n",ret);
    return 0;
}

3）写函数的实现过程。
int my_fun(int a,int b,int (*p)(int,int))        
{
    4）在函数的内部，只需要将p当做是函数名来处理就可以了
    return p(a,b);
}

问题一：传递了一个函数过来，那么形式参数如何写？
分析：在C语言中，传递了一个函数作为参数，其实就是传递了函数的地址过来，在形式参数中，只需要写一个函数指针变量来接住这个地址就可以了。

问题二：接住该函数的地址的函数指针变量如何写？是固定的写法？
不是固定的，传递不同类型的函数过来，这个函数指针写法是不一样。
按照以下步骤来写函数指针：
1）先写一个*                                             *
2）在*后面加上一个变量的名字，然后使用圆括号将结果括住。    (*p)
3）确认你传递的函数是长什么样子的？                       int add_fun(int x,int y)
4）将第3步的结果的函数名与形式参数的变量名去掉             int (int,int)
5）将第2步的结果写在第4步的结果的返回值类型与形式参数列表之间   int (*p)(int,int)

  最终得到的结果：   int (*p)(int,int)  -> 函数指针变量

   练习4： 连续从键盘中获取4个数字，求出其中的最大值。要求使用回调函数来完成。

#include <stdio.h>

int get_2_max(int x,int y)
{
    return (x > y ? x : y);
}

int get_4_max(int x,int y,int z,int k,int(*p)(int,int))
{
    int m;
    m = p(x,y); //求出x与y之间的最大值
    m = p(m,z); //求出x与y、z之间的最大值
    m = p(m,k); //求出四个数字中最大值
    return m;
}

int main(int argc,char *argv[])
{
    int a,b,c,d,ret;
    scanf("%d %d %d %d",&a,&b,&c,&d);
    
    ret = get_4_max(a,b,c,d,get_2_max);
    printf("ret = %d\n",ret);
    
    return 0;
}

六、内联函数。
1、什么是内联函数？
在程序中调用函数时，需要花费一定的时间进行保护现场，在函数返回时，需要花费一定时间来恢复现场，这样就会导致运行效率降低。
但是使用内联函数之后，就既可以使用函数的封装，又不需要花费时间来进行保护现场与恢复现场。

例子1：
int main(int argc,char *argv[])
{
    printf("helloworld!\n");
    printf("helloworld!\n");
    printf("helloworld!\n");
    return 0;
}

例子2：
void fun()
{
    printf("helloworld!\n");
    return;
}

int main(int argc,char *argv[])
{
        --> 花费一定的时间，保护现场
    fun();
        --> 花费一定的时间，恢复现场
        --> 花费一定的时间，保护现场
    fun();
        --> 花费一定的时间，恢复现场
        --> 花费一定的时间，保护现场
    fun();
        --> 花费一定的时间，恢复现场
    return 0;
}

2、如何实现内联函数？
1）先完成代码先。
#include <stdio.h>
void fun()
{
    printf("helloworld!\n");
    return;
}

int main(int argc,char *argv[])
{
        
    fun();    
    fun();    
    fun();    
    return 0;
}

2）将需要写成内联函数的函数接口前面加上一个关键词"inline"
#include <stdio.h>
inline void fun()
{
    printf("helloworld!\n");
    return;
}

int main(int argc,char *argv[])
{
        
    fun();    
    fun();    
    fun();    
    return 0;
}

3）把内联函数在.c文件中删除，然后新建一个.h文件，然后把内联函数写入到.h文件。

----------------------------test.c--------------------------
#include <stdio.h>

int main(int argc,char *argv[])
{
        
    fun();    
    fun();    
    fun();    
    return 0;
}

-----------------------------my_head.h-------------------------
inline void fun()
{
    printf("helloworld!\n");
    return;
}
----------------------------------------------------------------

4）在.c文件中对内联函数进行声明，以及包含自己写的头文件。

----------------------------test.c--------------------------
#include <stdio.h>
#include "my_head.h"

void fun();

int main(int argc,char *argv[])
{
        
    fun();    
    fun();    
    fun();    
    return 0;
}

-----------------------------my_head.h-------------------------
inline void fun()
{
    printf("helloworld!\n");
    return;
}
---------------------------------------------------------------

七、变参函数。
1、 什么是变参函数？
指的是参数不固定的函数，例如printf()
查询printf()命令: man 3 printf

        #include <stdio.h>

       int printf(const char *format, ...);

    format: 输出的字符串
    ...: 参数不定

例如：
printf("helloworld!\n");  -> 1个参数  参数1： "helloworld!\n"
printf("ret = %d\n",ret); -> 2个参数  参数1： "ret = %d\n"    参数2： ret

2、在linux下，有很多变参函数。
printf()  scanf()  fcntl()  ioctl()