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

﹏ヽ暗。殇╰゛Y 2022-11-25 10:06 202阅读 0赞

一、函数的声明。  
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;  
\}

七、变参函数。  
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()