【C语言】函数（下）：函数的嵌套调用 -- 链式访问 -- 声明 -- 定义 -- 递归 -- 练习

小灰灰 2023-09-27 15:04 19阅读 0赞

**目录**

1.函数的嵌套调用

2.链式访问

3.函数声明

4.函数定义

5.函数递归

5.1 什么是递归？

5.2 递归的两个必要条件

6.练习

--------------------

**PS：接上一篇函数文章，本篇继续：**

## 1.函数的嵌套调用 ##

**Q：什么是函数嵌套调用？**

*A：函数和函数之间可以根据实际的需求进行组合，也就是相互调用的。*

**Q：使用函数嵌套调用实现打印三行 hehe**

#include <stdio.h>
    void new_line()
    {
    	printf("hehe\n");
    }
    void three_line()
    {
    	for (int i = 0; i < 3; i++)
    	{
    		new_line();
    	}
    }
    int main()
    {
    	
    	three_line();
    	return 0;
    }

*效果展示：*

![1c83c646902c3d530f3d04febad4775e.png][]

**嵌套讲解：**

**main函数先调用了three\_line函数，在three\_line函数里，three\_line又调用了new\_line函数，这就是函数的嵌套调用。下面是图解：**

![e4d807f5c5d2c65b3f0b7b3622e0ffec.png][]

**注：函数可以实现嵌套调用，但是不可以嵌套定义，函数都是相互独立的。错误示范举例如下：**

这就是在A函数中定义B函数，这样是不允许的，编译器会报错。

![a579fcdedd5f33201da23fd597a80420.png][]

## 2.链式访问 ##

**Q：函数的链式访问是意思？**

*A：把一个函数的返回值作为另外一个函数的参数。*

**Q：我们计算一个字符串的长度，如何来写呢？**

A：代码如下：

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	int len = strlen("abcdef");
    	printf("%d\n", len);
    	return 0;
    }

效果展示：

![439bd5d927f92523400b6bd6e0c76241.png][]

我们这里使用了两个函数，strlen 函数和 printf 函数。我们先使用 len 将 strlen 函数计算出来的字符串长度保存起来，然后交给 printf 函数，作为 printf 函数的参数，最终实现打印。

我们现在不使用 len 来保存值，直接打印试试

#include <stdio.h>
    #include <string.h>
    int main()
    {
    	printf("%d\n", strlen("abcdef"));
    	return 0;
    }

效果展示：

![ccd4ed6994320ea3c9992721cff99d16.png][]

结果仍然正确。**这里就是链式访问，将 strlen 函数的返回值作为 printf 函数的参数进行打印。**

**我们来看一段链式访问代码：**

#include <stdio.h>
    
    int main()
    {
    	printf("%d", printf("%d", printf("%d", 23)));
    	return 0;
    }

*这段代码打印出来是什么呢？我们来看一下：*

![6fa2abffead8d8bb8c028588ffcf685d.png][]

**Q：为什么是2321呢？**

A：这里我们使用 c/c++ 的文库看一下库函数 printf 的返回值是怎么讲的。

![e3372ec81633df5b9543d531f23d7b98.png][]

![9bcf6de3d8760aee158c02e5d8ee2b7f.png][]

**我们看到这两个图片后，对代码再进行分析：**

![0d828642a9a6eff85391d6d9947c995b.png][]

这里打印出来的不是两千三百二十一，而是23--2--1。

## 3.函数声明 ##

1.告诉编译器有一个函数叫什么，参数是什么，返回值类型是什么。但是具体是不是存在，函数声明决定不了。

2.函数的声明一般出现在函数的使用之前。要满足**先声明，后使用。（变量也是一样的）**

3.函数的声明一般要放在头文件中。

**我们在这来看一段代码，使用实例进行讲解：**

我们在这写一个 Add 函数：

#include <stdio.h>
    int main()
    {
    	int a = 10;
    	int b = 20;
    	int ret = Add(a, b);
    	printf("%d\n", ret);
    	return 0;
    }
    int Add(int x, int y)
    {
    	int c = x + y;
    	return c;
    }

这段代码我们就是没做到先声明，后使用。编译器会报这样的错误：

![51a04a12f29661ccca26811f0f8138f8.png][]

它会报出 Add 未定义。但是我们确实已经定义了，这只是我们没有声明函数。

**解决办法：我们在主函数的前面进行声明，声明方法如下：**

//方法一
    int Add(int x, int y)；
    //方法二(省略参数名只在声明中允许，函数定义不可以)
    int Add(int , int )

**我们也可以将自定义函数写在主函数前面，这样就不需要对自定义函数进行声明，并且还可以正常使用它。**

**改写如下：**

#include <stdio.h>
    int Add(int x, int y)
    {
        int c = x + y;
    	return c;
    }
    int main()
    {
    	int a = 10;
    	int b = 20;
    	int ret = Add(a, b);
    	printf("%d\n", ret);
    	return 0;
    }

*效果展示：*

![6b3f6684d554b766a6e9645acd75c171.png][]

## 4.函数定义 ##

*函数的定义是指函数的具体实现，交代函数的功能实现。*

就像函数声明中的 Add 函数那样，代码如下：

int Add(int x, int y)
    {
        int c = x + y;
    	return c;
    }

## 5.函数递归 ##

### 5.1 什么是递归？ ###

**A：****程序调用自身的编程技巧****称为递归。**

递归作为一种算法在程序语言中广泛应用。一个过程或者函数在其定义或者说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略：只需少量的程序就可描述出解题过程所需的多次重复计算，大大地减少了程序的代码量。

**递归的主要思考方式在于：把大事化小。**

### 5.2 递归的两个必要条件 ###

***1.存在限制条件，当满足这个限制条件的时候，递归便不再继续。***

***2.每次递归调用之后越来越接近这个限制条件。***

**递归成立必须满足上面两个条件。**

**递归使用的时候这两个条件是非常重要的，我们反其道行之，举例来看看这两个条件的重要性：**

这里我们写一个没有限制的递归代码：

#include <stdio.h>
    int main()
    {
    	printf("hehe\n");
    	main();
    	return 0;
    }

*效果展示：*

![94c1a86af0084caae31aa40aa3d56396.png][]

*这就是没有两个必要条件的结果。因此，这两个条件是非常重要的。*

我们再以一个题来加深一下印象：

**题目：接受一个整形值（无符号），按照顺序打印它的每一位。例如：1234，输出 1 2 3 4。**

#include <stdio.h>
    //%u - 无符号整数（都为正，即使给的负数也当正数看待）
    //%d - 有符号整数
    void Print(unsigned int n)//封装一个Print函数
    {
    	if (n > 9)
    	{
    		Print(n / 10);
    	}
    	n = n % 10;
    	printf("%d ", n);
    }
    int main()
    {
    	unsigned int num = 0;
    	scanf("%u", &num);
    	Print(num);
    	return 0;
    }

*效果展示：*

![ad37597db36a3d50c0a784b1a8d3a0b6.png][]

**详解如下：**

![e57d56d06a70b90501019c3a3d71d188.png][]

**这段代码就清楚的向我们展示了这两个条件在递归中的重要性**

**1.如果没有限制条件会出现和打印 hehe 一样的问题，死循环。**

**2.每次递归都在接近限制条件。**

## 6.练习 ##

**1.题目：编写函数，****不允许****创建临时变量求字符串长度。**

*我们先看一下有临时变量的写法*

#include <stdio.h>
    //数组名是数组首元素的地址
    int my_strlen(char* str)
    {
    	int count = 0;
    	while (*str != '\0')
    	{
    		count++;
    		str++;
    	}
    	return count;
    }
    int main()
    {
    	char arr[] = "abcdef";
    	int len = my_strlen(arr);
    	printf("%d\n", len);
    
    	return 0;
    }

*效果展示：*

![e78b03cb8475e63dc5c06f4ebbfa025c.png][]

本题目有条件限制，不能创建临时变量，my\_strlen（）函数里面的 count 就是临时变量，所以这个是个错误的，但是思路大致是这样。strlen 函数的求字符串长度的原理就是找 '\\0' ，看 '\\0' 前面有多少个字符，所以我们的思路也是这样的。

我们对上面的代码进行改写：

#include <stdio.h>
    //数组名是数组首元素的地址
    int my_strlen(char* str)
    {
    	if (*str != '\0')
    		return 1 + my_strlen(str + 1);
    	else
    		return 0;
    }
    int main()
    {
    	char arr[] = "abc";
    	int len = my_strlen(arr);
    	printf("%d\n", len);
    
    	return 0;
    }

效果展示：

![04e94a912c564fab29da119879ed6901.png][]

**详解图示：**

![522359966f4aaae40a205951e45cc37a.png][]

**2.题目：求 n 的阶乘**

#include <stdio.h>
    int factorial(int n)
    {
    	if (n <= 1)
    		return 1;
    	else
    		return n * factorial(n - 1);
    }
    int main()
    {
    	int n = 0;
    	scanf("%d", &n);
    	int ret = factorial(n);
    	printf("%d\n", ret);
    
    	return 0;
    }

效果展示：

![3edee3db8bbc88e289a47dfb6ee467c8.png][]

**3.斐波那契数列**

#include <stdio.h>
    int fib(int n)
    {
    	if (n <= 2)
    		return 1;
    	else
    		return fib(n - 1) + fib(n - 2);
    }
    int main()
    {
    	int n = 0;
    	scanf("%d", &n);
    	int ret = fib(n);
    	printf("%d\n", ret);
    
    	return 0;
    }

效果展示1：

![42f3fe043d1e4b870796ee7594c0f1d1.png][]

效果展示2：

![5e414c5b8479f65f4d36b82c6afcb42f.png][]

**我们想一下fib（）函数怎么运行呢，我们以图来研究：**

![1bfdb62af21968e79c2fe5fe5840addf.png][]

这样就涉及十分大量的计算，计算机一直在工作，就是很费时间。

**所以这个代码就是告诉我们，递归可以解决好多问题，但是不一定就是最合适的，递归虽好，可不要贪啊。**

因此这个代码使用迭代写合适，下面我们对其进行改写：

#include <stdio.h>
    int fib(int n)
    {
    	int a = 1;
    	int b = 1;
    	int c = 1;
    	while (n > 2)
    	{
    		c = a + b;
    		a = b;
    		b = c;
    		n--;
    	}
    	return c;
    }
    int main()
    {
    	int n = 0;
    	scanf("%d", &n);
    	int ret = fib(n);
    	printf("%d\n", ret);
    
    	return 0;
    }

\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*函数章节完结\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*

[1c83c646902c3d530f3d04febad4775e.png]: https://img-blog.csdnimg.cn/img_convert/1c83c646902c3d530f3d04febad4775e.png
[e4d807f5c5d2c65b3f0b7b3622e0ffec.png]: https://img-blog.csdnimg.cn/img_convert/e4d807f5c5d2c65b3f0b7b3622e0ffec.png
[a579fcdedd5f33201da23fd597a80420.png]: https://img-blog.csdnimg.cn/img_convert/a579fcdedd5f33201da23fd597a80420.png
[439bd5d927f92523400b6bd6e0c76241.png]: https://img-blog.csdnimg.cn/img_convert/439bd5d927f92523400b6bd6e0c76241.png
[ccd4ed6994320ea3c9992721cff99d16.png]: https://img-blog.csdnimg.cn/img_convert/ccd4ed6994320ea3c9992721cff99d16.png
[6fa2abffead8d8bb8c028588ffcf685d.png]: https://img-blog.csdnimg.cn/img_convert/6fa2abffead8d8bb8c028588ffcf685d.png
[e3372ec81633df5b9543d531f23d7b98.png]: https://img-blog.csdnimg.cn/img_convert/e3372ec81633df5b9543d531f23d7b98.png
[9bcf6de3d8760aee158c02e5d8ee2b7f.png]: https://img-blog.csdnimg.cn/img_convert/9bcf6de3d8760aee158c02e5d8ee2b7f.png
[0d828642a9a6eff85391d6d9947c995b.png]: https://img-blog.csdnimg.cn/img_convert/0d828642a9a6eff85391d6d9947c995b.png
[51a04a12f29661ccca26811f0f8138f8.png]: https://img-blog.csdnimg.cn/img_convert/51a04a12f29661ccca26811f0f8138f8.png
[6b3f6684d554b766a6e9645acd75c171.png]: https://img-blog.csdnimg.cn/img_convert/6b3f6684d554b766a6e9645acd75c171.png
[94c1a86af0084caae31aa40aa3d56396.png]: https://img-blog.csdnimg.cn/img_convert/94c1a86af0084caae31aa40aa3d56396.png
[ad37597db36a3d50c0a784b1a8d3a0b6.png]: https://img-blog.csdnimg.cn/img_convert/ad37597db36a3d50c0a784b1a8d3a0b6.png
[e57d56d06a70b90501019c3a3d71d188.png]: https://img-blog.csdnimg.cn/img_convert/e57d56d06a70b90501019c3a3d71d188.png
[e78b03cb8475e63dc5c06f4ebbfa025c.png]: https://img-blog.csdnimg.cn/img_convert/e78b03cb8475e63dc5c06f4ebbfa025c.png
[04e94a912c564fab29da119879ed6901.png]: https://img-blog.csdnimg.cn/img_convert/04e94a912c564fab29da119879ed6901.png
[522359966f4aaae40a205951e45cc37a.png]: https://img-blog.csdnimg.cn/img_convert/522359966f4aaae40a205951e45cc37a.png
[3edee3db8bbc88e289a47dfb6ee467c8.png]: https://img-blog.csdnimg.cn/img_convert/3edee3db8bbc88e289a47dfb6ee467c8.png
[42f3fe043d1e4b870796ee7594c0f1d1.png]: https://img-blog.csdnimg.cn/img_convert/42f3fe043d1e4b870796ee7594c0f1d1.png
[5e414c5b8479f65f4d36b82c6afcb42f.png]: https://img-blog.csdnimg.cn/img_convert/5e414c5b8479f65f4d36b82c6afcb42f.png
[1bfdb62af21968e79c2fe5fe5840addf.png]: https://img-blog.csdnimg.cn/img_convert/1bfdb62af21968e79c2fe5fe5840addf.png