【c语言】三、函数与函数递归-爱代码爱编程
三、函数
1.函数是什么
2.库函数
3.自定义函数
4.函数参数
5.函数调用
6.函数的嵌套调用和链式访问
7.函数的声明和定义
8.函数递归
3.1 函数是什么?
● 在计算机科学中,子程序,是一个大型程序中的某部分代码,由一个或多个语句块组成。它负责完成某项 特定任务,而且相较于其他代 码,具备相对的独立性。
● 一般会有输入参数并有返回值,提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
3.2 C语言中函数的分类
1.库函数
2.自定义函数
3.2.1 库函数
C语言的编译器提供了一些库函数:如printf,scanf,strlen。
库函数如何实现,用户不用管,实现是交给编译器厂商实现的
可以在www.cplusplus.com学习C语言库函数
介绍两个库函数
//strcpy
//函数声明 destination为目的字符串,source为源字符串,将源字符串复制到目的字符串中
char *strcpy(char *destination, const char *source);
#include <string.h> //strcpy库函数在string.h中,密码要包含头文件才能使用
int main()
{
char destination[99] = "xxx";
char source[] = "Hello World\n";
strcpy(destination, source);
printf("%s\n", destination); //Hello World
return 0;
}
//程序打印Hello World
//memset
void * memset ( void * ptr, int value, size_t num );
//功能将前num字符初始化为value
#include <string.h>
int main()
{
char arr[] = "Hello World";
memset(arr, 'x', 5);
printf("%s\n", arr);
return 0;
}
//程序输出xxxxx World
3.2.2 自定义函数
库函数已经无法满足程序员,就需要使用自定义函数了。
自定义函数和库函数一样,有函数名,返回值类型和函数参数。
//写一个函数可以找出两个整数中的最大值。
// get_max自定义函数的设计
int get_max(int x, int y)
{
return (x > y) ? (x) : (y);
}
int main()
{
int num1 = 10;
int num2 = 20;
int max = get_max(num1, num2); //调用自定义函数
printf("max = %d\n", max); // max=20
return 0;
}
3.3 函数的参数
3.3.1 实际参数(实参)
真实传给函数的参数,叫实参。
实参可以是:常量、变量、表达式、函数等。
无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参。
3.3.2 形式参数(形参)
形式参数是指函数名后括号中的变量,因为形式参数只有在函数被调用的过程中才实例化(分配内存单元),所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
//写一个函数可以交换两个整形变量的内容。
void Swap1(int x, int y) // 传的是两个值 两个值交换变量,改变的是形参,不会改变实参
{
int tmp = 0;
tmp = x;
x = y;
y = tmp;
}
// 正确的版本
void Swap2(int *px, int *py)
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int num1 = 1;
int num2 = 2;
Swap1(num1, num2); // 传值调用
printf("Swap1::num1 = %d num2 = %d\n", num1, num2); //Swap1::num1 = 1 num2 = 2
Swap2(&num1, &num2); // 传址调用
printf("Swap2::num1 = %d num2 = %d\n", num1, num2); //Swap2::num1 = 2 num2 = 1
return 0;
}
//当函数调用的时候
//实参传给形参时,形参将是实参的一份临时拷贝,所以对形参的修改是不影响实参的
//只有实参传递的是地址,在通过对指针的解引用才能改变实参。
上面Swap1和Swap2函数中的参数 x,y,px,py 都是形式参数。在main函数中传给 Swap1的num1 ,num2 和传给Swap2函数的&num1 ,&num2是实际参数。
这里我们对函数的实参和形参进行分析:
可以看到实参num1和num2 形参x,y使用的不是同一空间
形参实例化之后其实相当于实参的一份临时拷贝。
3.4 函数的调用
3.4.1 传值调用
函数的形参和实参分别占有不同内存块,对形参的修改不会影响实参。
3.4.2 传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起真正的联系,也就是函数内部可以直接操 作函数外部的变量。
3.5 函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的,也就是互相调用的。
3.5.1 嵌套调用
void new_line()
{
printf("hehe\n");
}
void three_line()
{
int i = 0;
for (i = 0; i < 3; i++)
{
new_line();
}
}
int main()
{
three_line();
return 0;
}
函数可以嵌套调用,但是不能嵌套定义。
3.5.2 链式访问
把一个函数的返回值作为另外一个函数的参数。
#include <string.h>
int main()
{
char arr[20] = "hello";
int ret = strlen(strcat(arr, "world")); // strcat连接 hellobit 10个字符
printf("%d\n", ret);
return 0;
}
//strcat是字符串连接函数,将helloworld连接起来 strlen求字符串长度,所以结果为10
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
//结果是啥?
//注:printf函数的返回值是打印在屏幕上字符的个数
return 0;
}
//打印的是4321 程序中最右边的printf先执行打印43,然后返回函数的结果,两个字符就返回2,然后打印2,返回1,打印1
3.6 函数的声明和定义
3.6.1 函数声明
1.告诉编译器有一个函数叫什么,参数是什么,返回类型是什么。但是具体是不是存在,函数声明决定不了。
2.函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3.函数的声明一般要放在头文件中。
int Add(int, int);
int Add(int x, int y);
int main()
{
int a = 10;
int b = 20;
int s = Add(a, b);
printf("%d\n", s);
return 0;
}
//如果这里的Add没有声明,那么程序就会报错,main函数中找不到Add。因为Add定义在main函数的后面,如果写在main函数的前面就可以不用声明
int Add(int x, int y)
{
return x + y;
}
3.6.2 函数定义
函数的定义是指函数的具体实现,交待函数的功能实现。
函数的定义和声明要分模块写
3.7 函数递归
3.7.1 什么是递归?
程序调用自身的编程技巧称为递归。
递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解, 递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。
递归的主要思考方式在于:把大事化小
3.7.2 递归的两个必要条件
1.存在限制条件,当满足这个限制条件的时候,递归便不再继续。
2.每次递归调用之后越来越接近这个限制条件。
//接受一个整型值(无符号),按照顺序打印它的每一位。输入:1234,输出 1234 用递归实现
void print(int num)
{
if (num > 9)
{
print(num / 10);
}
printf("%d", num % 10);
}
int main()
{
int num = 1234;
print(num);
return 0;
}
//print(123) 4
//print(12) 3 4
//print(1) 2 3 4
//编写函数不允许创建临时变量,求字符串的长度
int Strlen(char *arr)
{
if (*arr != '\0')
return 1 + Strlen(arr + 1);
else
return 0;
}
int main()
{
char arr[] = "abc";
int len = Strlen(arr);
printf("%d", len);
return 0;
}
//思路:如果strlen的长度一开始不为\0,那么长度就是1 + 剩余的递归,如果等于\0,长度则为0
3.7.3 递归与迭代
// 求n的阶乘。(不考虑溢出)
int factorial(int n)
{
if (n <= 1)
{
return 1;
}
else
{
return n * factorial(n - 1);
}
}
int main()
{
int n = 0;
scanf("%d", &n);
int sum = factorial(n);
return 0;
}
//思路:比如3的阶乘=3*2*1
//1的阶乘等于1,返回1 2的阶乘等于2*1的阶乘
//所以阶乘递归公式n * factorial(n - 1)
//求第n个斐波那契数。(不考虑溢出)
//斐波那契数就是1 1 2 3 5 8 13 前两数相加等于第三个数
int fib(int n)
{
if (n <= 2)
return 1;
else
return fib(n - 1) + fib(n - 2);
}
上面2个递归在n较小的时候没有问题
在使用 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);
}
int main()
{
fib(50);
printf("count\n");
return 0;
}
最后我们输出看看count,是一个很大很大的值。
在调试 factorial 函数的时候,如果你的参数比较大,那就会报错: stack overflow(栈溢出) 这样的信息。
系统分配给程序的栈空间是有限的,但是如果出现了死循环,或者(死递归),这样有可能导致一 直开辟栈空间,最终产生栈空间耗尽的情况,这样的现象我们称为栈溢出。
那如何解决上述的问题:
1.将递归改写成非递归。
2.使用static对象替代nonstatic局部对象。在递归函数设计中,可以使用static对象替代nonstatic局部对象(即栈对象),这不 仅可以减少每次递归调用和返回时产生和释放nonstatic 对象的开销,而且static对象还可以保存递归调用的中间状态,并且可为各个调用层所访问。
结论:
1.许多问题是以递归的形式进行解释的,这只是因为它比非递归的形式更为清晰。
2.但是这些问题的迭代实现往往比递归实现效率更高,虽然代码的可读性稍微差些。
3.当一个问题相当复杂,难以用迭代实现时,此时递归实现的简洁性便可以补偿它所带来的运行时开销。