文章目录
- 6. 函数的嵌套调用和链式访问
- 6.1 嵌套调用
- 6.2 链式访问
- 7. 函数的声明和定义
- 7.1 函数声明
- 7.2 函数定义
- 8. 函数递归
- 8.1 什么是递归
- 8.2 递归的两个必要条件
- 8.3 递归与迭代
- 附：
6. 函数的嵌套调用和链式访问
6.1 嵌套调用
#include <stdio.h>
int test(int a, int b)
{
return a + b;
}
void fun()
{
int ret = test(2, 3);
printf("hehe\n");
}
int main()
{
return 0;
}
注： 函数可以嵌套调用,但是不存在嵌套定义
//以下写法是错误的
#include <stdio.h>
int test(int a, int b)
{
return a + b;
void fun()
{
printf("hehe\n");
}
}
int main()
{
return 0;
}
6.2 链式访问
把一个函数的返回值作为另外一个函数的参数。
#include <stdio.h>
#include <string.h>
int main()
{
//int len = strlen("abcdef");
//printf("%d\n", len);
//链式访问
printf("%d\n", strlen("abcdef"));
return 0;
}
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
}
//4321
#include <stdio.h>
int main()
{
printf("%d ", printf("%d ", printf("%d ", 43)));
return 0;
}
//43 3 2
7. 函数的声明和定义
7.1 函数声明
- 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么，但是具体是不是存在，函数声明决定不了。
- 函数的声明一般出现在函数的使用之前，要满足先声明后使用。
- 函数的声明一般要放在头文件中。
#include <stdio.h>
//函数声明
//int Add(int, int);
int Add(int x, int y);//这两种写法都可以
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//加法
int c = Add(a, b);//函数调用
//打印
printf("%d\n", c);
return 0;
}
//函数的定义
int Add(int x, int y)
{
return x + y;
}
7.2 函数定义
函数的定义是指函数的具体实现，交待函数的功能实现。
#include <stdio.h>
//函数的定义-定义是一种特殊的声明
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//加法
int c = Add(a, b);//函数调用
//打印
printf("%d\n", c);
return 0;
}
- 函数的声明和定义其实通常不是这样使用的
- 函数的声明是放在头文件中的
//add.h
//函数的声明
int Add(int x, int y);
//add.c
//函数定义
int Add(int x, int y)
{
return x + y;
}
//test.c
#include <stdio.h>
#include "add.h"
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//加法
int c = Add(a, b);//函数调用
//打印
printf("%d\n", c);
return 0;
}
再举一个简单的例子：假设有一位程序员写了一个能够求两数相加之和的函数，他想卖给别人使用，但又不想让别人看到他的源代码，他应该怎么做呢？
首先，他需要写一个.h文件（在.h文件中声明函数，同时可以通过注释来解释函数的功能、参数和返回值）
//add.h
//函数
//函数的功能
//参数
//返回值
int Add(int x, int y);
接着，他需要写一个.c文件
int Add(int x, int y)
{
return x + y;
}
最后，将其改为静态库；之后就可以将静态库和头文件卖给别人。（买方买到静态库后打开查看只能看到一堆乱码，因为代码已经转换为二进制了，不需要担心源代码会被看到。）
买方买到他的静态库和头文件后，先将其添加到他所写的项目的文件夹中，之后用如下代码：
#include <stdio.h>
#include "add.h"
//.lib - 静态库
//导入静态库
#pragma comment(lib, "add.lib")
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//加法
int c = Add(a, b);//函数调用
//打印
printf("%d\n", c);
return 0;
}
8. 函数递归
8.1 什么是递归
- 程序调用自身的编程技巧称为递归（简单来说就是函数自己调用自己；递 --> 递推 归 --> 回归）。
- 递归做为一种算法在程序设计语言中广泛应用，是一个过程或函数在其定义或说明中有直接或间接
调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问
题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程
序的代码量。- 递归的主要思考方式在于：把大事化小。
//以下就是一个简单的递归；但是这个递归会死递归，导致栈溢出
#include <stdio.h>
int main()
{
printf("hehe\n");
main();
return 0;
}
8.2 递归的两个必要条件
- 存在限制条件，当满足这个限制条件的时候，递归便不再继续。
- 每次递归调用之后越来越接近这个限制条件。
以下为两个例题，用以更好地理解递归的两个必要条件
接收一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234 输出： 1 2 3 4
void print(unsigned int n)//1234
{
if (n > 9)
{
print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
unsigned int num = 0;
//输入
scanf("%d", &num);
print(num);
return 0;
}
编写函数不允许创建临时变量，求字符串的长度。
首先，我们先写一个求字符串长度的代码
#include <stdio.h>
#include <string.h>
int main()
{
char arr[] = "abc";
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
上面用的是库函数，那能不能自己编写一个函数来求字符串长度呢
#include <stdio.h>
int my_strlen(char* s)
{
int count = 0;
while (*s != '\0')
{
count++;
s++;
}
return count;
}
int main()
{
char arr[] = "abc";
//[a b c \0]
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
最后，再加上条件：不允许创建临时变量
//my_strlen("abc")
//1+my_strlen("bc")
//1+1+my_strlen("c")
//1+1+1+my_strlen("")
//1+1+1+0
//3
//
//递归
#include <stdio.h>
int my_strlen(char* s)
{
if (0 == *s)
{
return 0;
}
else
{
return 1 + my_strlen(s + 1);
}
}
int main()
{
char arr[] = "abc";
//[a b c \0]
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
8.3 递归与迭代
求n的阶乘。（不考虑溢出）
//n! = 1*2*3*4...*n
//循环（迭代）
#include <stdio.h>
int Fac(int n)
{
int r = 1;
int i = 0;
for (i = 1; i <= n; i++)
{
r = r * i;
}
return r;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d\n", ret);
return 0;
}
//递归
#include <stdio.h>
int Fac(int n)
{
if (n <= 1)
{
return 1;
}
else
{
return n * Fac(n - 1);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d\n", ret);
return 0;
}
求第n个斐波那契数。（不考虑溢出）
//求第n个斐波那契数
//1 1 2 3 5 8 13 21 34 55 ...
//前2个的数的和是第三个数
#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;
}
//迭代写法
#include <stdio.h>
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while (n >= 3)
{
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;
}
但是我们在使用递归的时候会发现以下问题：
- 使用Fac函数求10000的阶乘（不考虑结果的正确性），程序会崩溃。
- 使用Fib这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。
问题原因：
- 系统分配给程序的栈空间是有限的，但是如果出现了死递归，这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
- Fib函数在调用的过程中很多计算其实在一直重复。
如何解决上述的问题：
- 将递归改写成非递归。
- 使用static对象替代nonstatic局部对象。在递归函数设计中，可以使用static对象替代nonstatic局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
以下是对于第二点的一个具体举例：
求n的阶乘。（不考虑溢出）
#include <stdio.h>
int Fac(int n)
{
static int result = 1;
if (n <= 1)
{
return result;
}
else
{
result *= n;
return Fac(n - 1);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d\n", ret);
return 0;
}
提示：
1, 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。
附：
函数（1）
![Prompt工程师指南[从基础到进阶篇]：用于开发和优化提示，以有效地使用语言模型（LMs）进行各种应用和研究主题](https://img-blog.csdnimg.cn/img_convert/ed258197ba9c79ff2534a8eff66e28da.png)
![[GXYCTF2019]BabyUpload1](https://img-blog.csdnimg.cn/img_convert/53399c8c116f415182edad129448e1e7.png)
