🌹作者:云小逸
📝个人主页:云小扬的主页
📝码云：云小扬 (YunXiaoYang003) - Gitee.com
🤟motto:要敢于一个人默默的面对自己，强大自己才是核心。不要等到什么都没有了，才下定决心去做。种一颗树，最好的时间是十年前，其次就是现在！学会自己和解，与过去和解，努力爱自己。希望春天来之前，我们一起面朝大海，春暖花开！🤟
👏专栏：C语言初阶👏专栏：C语言进阶👏专栏：数据结构和算法👏
👏专栏：C++初阶—👏专栏：C++进阶–👏专栏：Linux学习👏
文章目录
前言
5.函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
a. 函数的调用
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
int add1(int num)
{
return num++;
}//无效，因为是先传值再递增
int add2(int num)
{
return ++num;
}
void add3(int* p)
{
return *p = *p + 1;
}
void add4(int* p)
{
return ++*p ;
}
int main(void)
{
int num = 0;
num=add1(num);
printf("num=%d//无效，因为是先传值再递增\n", num);//无效，因为是先传值再递增
num=add2(num);
printf("num=%d\n", num);
add3(&num);
printf("num=%d\n", num);
add4(&num);
printf("num=%d\n", num);
return 0;
}
b.函数的嵌套调用
嵌套调用就是某个函数调用另外一个函数（即函数嵌套允许在一个函数中调用另外一个函数）。
函数可以嵌套调用，但是不能嵌套定义。
#include <stdio.h>
void new_line()
{
printf("haha\n");
}
void three_line()
{
int i = 0;
for (i = 0; i < 3; i++)
{
new_line();
}
}
int main()
{
three_line();
return 0;
}
c.函数的链式访问
把一个函数的返回值作为另外一个函数的参数。
（1）strlen和strcat的链式访问
#include<stdio.h>
#include<string.h>
int main(void)
{
char arr[20] = "hello";
int ret = strlen(strcat(arr, "bit"));
printf("%d",ret);
return 0;
}
（2）printf的链式访问
#include<stdio.h>
#include<string.h>
//int main(void)
//{
// char arr[20] = "hello";
// int ret = strlen(strcat(arr, "bit"));
// printf("%d",ret);
// return 0;
//}
int main(void)
{
printf("%d", printf("%d", printf("43")));
return 0;
}
解析：
上面这个是printf函数的返回值解释。
第一行：On success, the total number of characters written is returned.
the total number of characters 表示为字符个数，即返回为字符的个数
因此得出结果为4321
6. 函数的声明和定义
a.函数声明：
- 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数 声明决定不了。
- 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
- 函数的声明一般要放在**头文件**中的。
b.函数定义：
函数的定义是指函数的具体实现，交待函数的功能实现。
c.举例：
test.h的内容
放置函数的声明
#ifndef __TEST_H__
#define __TEST_H__
//函数的声明
int Add(int x, int y);
#endif //__TEST_H__
test.c的内容
放置函数的实现
#include "test.h"
//函数Add的实现
int Add(int x, int y)
{
return x+y;
}
7.函数的递归
a.递归的概念
程序调用自身的编程技巧称为递归（ recursion）。
递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，
它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，
递归策略
只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
递归的主要思考方式在于：把大事化小
b. 递归的两个必要条件
1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件。
c.练习讲解：
（1）接受一个整型值（无符号），按照顺序打印它的每一位。
#include<stdio.h>
void Printf(unsigned int num)
{
if (num > 9)
{
Printf(num / 10);
}
printf("%d ", num % 10);
}
int main(void)
{
int num = 1234;
Printf(num);
return 0;
}
（2）编写函数不允许创建临时变量，求字符串的长度。
反例：建立临时变量
#include<stdio.h>
int my_strlen(char* s)
{
int count = 0;
while (*s != '\0')
{
count++;
*s++;
}
return count;
}
int main(void)
{
char arr[20] = "abc";
printf("%d", my_strlen(arr));
return 0;
}
正确例子：不建立临时变量
#include<stdio.h>
//int my_strlen(char* s)
//{
// int count = 0;
// while (*s != '\0')
// {
// count++;
// *s++;
// }
// return count;
//}
int my_strlen(char* s)
{
if (*s == '\0')
return 0;
else
return 1 + my_strlen(++s);
}
int main(void)
{
char arr[20] = "abc";
printf("%d", my_strlen(arr));
return 0;
}
8.递归与迭代
a.求n的阶乘。（不考虑溢出）
int factorial(int n)
{
if(n <= 1)
return 1;
else
return n * factorial(n-1);
}
b.求第n个斐波那契数。（不考虑溢出）
int fib(int n)
{
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
但是我们发现有问题；
在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。 使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。为什么呢？
我们发现 fib 函数在调用的过程中很多计算其实在一直重复。 如果我们把代码修改一下：
`int count = 0;//全局变量
int fib(int n)
{
if(n == 3)
count++;
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
最后我们输出看看count，是一个很大很大的值。
很可能会栈溢出
c.改进：
非递归写法：
//求n的阶乘
int factorial(int n)
{
int result = 1;
while (n > 1)
{
result *= n ;
n -= 1;
}
return result;
}
//求第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;
}
那我们如何改进呢？
在调试 factorial 函数的时候，如果你的参数比较大，那就会报错： stack overflow（栈溢出）
这样的信息。 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一
直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出
那如何解决上述的问题：
1. 将递归改写成非递归。
2. 使用static对象替代 nonstatic 局部对象。
在递归函数设计中，可以使用 static 对象替代
nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为
各个调用层所访问
d.提示：
1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开
销。
最后
十分感谢你可以耐着性子把它读完和我可以坚持写到这里，送几句话，对你，也对我：
1.人是在一瞬间改变的，而不是看了好多书，认识好多人，慢慢改变的。是看到人家，一天赚了2000，一个月赚了6万，而且这个人，是从小跟我们一块儿长大的，我们知根知底。此生，再也睡不着了，每天浑身发热，想改变，蜕变，疯狂，这种感觉出来了，冲起来的概率大点儿。
2.社交的本质是价值交换。
想想那些拒绝帮助你的人，是不是你对他们来说没有可利用的价值
3.人与人之间的教育差距，地域差异以及人的观念，真的会颠覆你的想象
当你还在宿舍浑浑噩噩打游戏时，你的舍友可能已经开始创业挣钱
4…舍友可能是你大学里最好的朋友，但也有可能仅仅是跟你住了四年的陌生人而已
能遇见对的人是很幸运的，遇见不了也别强求!
最后如果觉得我写的还不错，请不要忘记点赞✌，收藏✌，加关注✌哦(｡･ω･｡)
愿我们一起加油，奔向更美好的未来，愿我们从懵懵懂懂的一枚菜鸟逐渐成为大佬。加油，为自己点赞！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
