C语言 函数 （库函数 · 自定义函数 · 函数参数 · 函数调用 · 嵌套调用链式访问 · 递归）

一、函数是什么？

数学中有函数的概念，C语言中也有函数的概念。但是你了解C语言中的函数吗？

• 在计算机科学中，子程序是一个大型程序中的某个部分代码，由一个或者多个语句块组成。它负责完成某项特定任务，而且相比于其他代码，具备相对的独立性。
• 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
• C语言中函数的分类：库函数和自定义函数。

---

二、库函数

2.1 为什么要有库函数？

1. 我们在编写程序的时候，想看一下输出到屏幕上的结果。这个时候我们会频繁的调用一个函数来帮我们完成输出任务：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的时候，我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 我们在编程的时候，也会涉及到数学计算，其中就会有计算 n 的 k 次方这样的运算（pow）。

像我们上述提及的函数方法，都不是业务代码。而是C语言中为了方便程序员开发，为了提高程序效率和支持可移植性，提供的库函数。

2.2 如何学习库函数？

这里我们简单的看看： www.cplusplus.com.

简单的总结：C语言中常用的库函数有：

• IO 函数
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间 / 日期函数
• 数学函数
• 其他库函数

2.3 我们就以 strcpy( ) 函数，来参照文档自学一下：

第一步：打开网址，在上面空格内输入 strcpy

第二步：查看库函数的结构和英文注释

第三步：鼠标下滑，可以看到Example

第四步：自行代码演示操作一下

2.4 总结：

1. 使用库函数，不要忘记要 #include 引用头文件。
2. 库函数有很多，我们不能全部记住，这个时候我们要学会如何查询库函数，如何从文档中学习库函数。

库函数查询工具：

MSDN(Microsoft Developer Network)

www.cplusplus.com

http://en.cppreference.com

---

三、自定义函数

如果库函数可以把程序开发所有任务都完成，那还需要程序员做什么？

所有更加重要的是自定义函数。

自定义函数和库函数一样，都有函数名，返回值类型和函数参数。但不一样的是，这些都是我们自己来设计的，这就给程序员很大的发挥空间。

3.1 函数的组成：

ret_type   fun_name(para1, * )
{
	statement;//语句项
}
ret_type 返回类型
fun_name 函数名
para1   函数参数

3.2 我们举个例子：

1. 写一个计算两个数据最大值的函数：

//自定义函数设计
int getMax(int n1,int n2) {
	return n1 > n2 ? n1 : n2;
}

int main() {
	//自定义函数
	int num1 = 10;
	int num2 = 20;
	int max = getMax(num1,num2);
	printf("%d\n", max);
	return 0;
}

再来一个例子：

2. 写一个可以交换两个整型变量的函数：

void Swap1(int n1,int n2) {
	int temp = n1;
	n1 = n2;
	n2 = temp;
}
void Swap2(int* a,int* b) {
	int temp = *a;
	*a = *b;
	*b = temp;
}

int main() {
	//自定义函数
	int num1 = 10;
	int num2 = 20;

	Swap1(num1,num2);
	printf("%d,%d\n", num1, num2);

	Swap2(&num1, &num2);
	printf("%d,%d\n", num1,num2);

	return 0;
}

输出结果：

第一个printf 打印的数据没有交换，第二个 printf 打印的数据有交换。这是为什么呢？

那让我们来调试一下程序，找一下原因：

这里是 Swap1 函数，我们可以看到 main 函数中的 num1 和 num2 数据都传输给 Swap1，n1 和 n2 变量也都接收到数据了👌

运行完Swap1函数，n1和n2也完成交换，至此Swap1函数执行完毕。

这么一看好像没什么问题，数据在Swap1函数内完成交换。但是为什么输出结果没有完成交换呢？我们查看一下四个数据的地址

四个变量的地址都是不一样的，说明各自在内存中存储的位置不一样。你n1，n2交换，和我num1和num2什么事？

那么，有什么办法可以让彼此的地址关联起来呢？答案是 利用指针。

Swap2自定义函数中，就使用了指针，取num1和num2的地址，传输给Swap2的指针变量a和b接收。这个时候，可以看到地址是一样的了。

a和b完成数据交换，同时num1和num2也完成数据交换。
绿框中的地址是，Swap2函数为a和b在内存中分配的地址。虽然是新地址，但是新地址内部存储的是之前指针变量接收的地址。

---

四、函数的参数

4.1 实际参数（实参）：

真实传递给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

4.2 形式参数（形参）：

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。
形式参数当函数调用完成之后就自动销毁了。因此形式参数只有在函数中才有效。

我们刚刚举例的Swap1和Swap2函数中的参数n1,n2,a,b都是形式参数。
在main函数中传递给Swap1的num1，num2和传递给Swap2函数的&num1，&num2都是实际参数。

---

五、函数的调用

传值调用：

函数的形参和实参，都分别占用不同的内存块。对形式参数修改内容，不会影响到实际参数。
Swap1函数就是传值调用。

传址调用：

把函数外部创建变量的内存地址，传递给函数参数的一种调用函数的方式。
这种传参方式，可以让函数和函数外边的变量创建真正的联系，也就是函数内部可以直接操作函数外部的变量。
Swap2函数就是传址调用。

练习题：

1. 写一个函数可以判断一个是是不是素数。

#include<math.h>
int is_prime(int n) {
	int a = 0;
	for (a = 2; a <= sqrt(n); a++) {
		if (n % a == 0) {
			return 0;
		}
	}
	return 1;
}
int main() {
	int i = 0;
	printf("请输入一个整数：");
	scanf("%d", &i);
	if (is_prime(i) == 1) {
		printf("%d 是素数\n", i);
	}
	else {
		printf("%d 不是素数\n", i);
	}
	return 0;
}

2. 写一个函数判断一年是不是闰年。

//写一个函数判断一年是不是闰年。
#include <stdio.h>
int is_leap_year(int i) {
	if ((i % 4 == 0 && i % 100 != 0) || i % 400 == 0) {
		return 1;
	}
	return 0;
}
int main() {
	int year = 0;
	printf("请输入年份：");
	scanf("%d", &year);
	if (is_leap_year(year) == 1) {
		printf("%d是闰年", year);
	}
	else {
		printf("%d不是闰年", year);
	}
	return 0;
}

3. 写一个函数，实现一个整形有序数组的二分查找。

//写一个函数，实现一个整形有序数组的二分查找。
#include <stdio.h>
int binary_search(int a[], int k, int sz) {
	int left = 0;
	int right = sz - 1;
	while (left <= right) {
		int mid = (left + right) / 2;
		if (a[mid] < k) {
			left = mid + 1;
		}
		else if (a[mid] > k) {
			right = mid - 1;
		}
		else {
			return mid;
		}
	}
	return -1;
}
int main() {
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int key = 7;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret = binary_search(arr, key, sz);
	
	if (-1 == ret) {
		printf("没有找到该数据！");
	}
	else {
		printf("找到了！该数据下标为：%d\n", ret);
	}
	return 0;
}

4. 写一个函数，每调用一次这个函数，就会将num的值增加1。

//写一个函数，每调用一次这个函数，就会将num的值增加1。
void Add01(int* n) {
	(*n)++;
}
int main() {
	int num = 0;
	Add01(&num);
	printf("%d\n", num);

	Add01(&num);
	printf("%d\n", num);

	Add01(&num);
	printf("%d\n", num);
	return 0;
}

---

六、函数的嵌套调用和链式访问

函数和函数之间是可以组合的

嵌套调用

#include <stdio.h>
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;
}

链式访问

把一个函数的返回值作为另一个函数的参数。

strlen( ) ：计算字符串长度
strcat(a, b)：把 b 字符串拼接到 a 后面

#include <string.h>
int main() {
	char arr[20] = "hello";
	int ret = strlen(strcat(arr, "world"));
	printf("%d\n", ret);
	return 0;
}

相关小练习：请问输出结果是啥？

int main() {
	printf("%d", printf("%d", printf("%d", 43)));
	return 0;
}

---

七、函数的声明和定义

函数声明：

1. 告诉编译器有一个函数叫什么，参数是什么，返回值类型是什么。但是不会理会是否存在该函数。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般放在头文件里面。

函数定义：

函数的定义指函数的具体实现，交待函数的功能实现。

int main() {
	int a = 10;
	int b = 20;

	//函数的声明
	int bdd(int x, int y);

	int c = bdd(a, b);
	printf("%d\n", c);
	return 0;
}
//函数的定义
int bdd(int x, int y) {
	return x + y;
}

不过未来实际开发是分模块的，需要在别的地方写好函数方法，然后让主函数来调用。这个时候，主函数就要先声明一下函数才能调用。

随便举个例子：

在test.h文件中放函数的声明：

//函数的声明
int Add(int x, int y);

在test.c文件中放置函数的实现：

#include "test.h" --引用函数的声明
//函数Add的实现
int Add(int x, int y)
{
	return x+y;
}

未来会在后续博客中继续提及这种书写形式，这里就提一下就好了。

---

八、函数的递归

什么是递归？

程序调用自身编程技巧便称为递归。递归做为一种算法在程序设计语言中广泛的应用。

递归通常把一个大型复杂的问题层层转化为一个规模较小的问题来求解。递归的方法只需要少量的程序，就可以描述出解题过程中需要的多次重复计算，大大减少了程序的代码量。

递归的主要思想就是：大事化小

递归的两个必要条件。

1. 存在限制条件，可以用于停止继续递归。
2. 每次递归后，越来越接近这个限制条件。

练习题1：

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

#include <stdio.h>
void print(int n) {
	if (n > 9) {
		print(n / 10);
	}
	printf("%d ", n % 10);
}
int main() {
	int num = 0;
	scanf("%d", &num);
	print(num);
	return 0;
}

图解：

练习题2：

编写函数不允许创建临时变量，求字符串的长度。

//编写函数不允许创建临时变量，求字符串的长度。
#include <stdio.h>
方式一：创建了临时变量的方式
//int my_strlen(char* str) {
//	int count = 0;
//	while (*str != '\0') {
//		count++;
//		str++;
//	}
//	return count;
//}

//方式二：没有创建临时变量
int my_strlen(char* str) {
	if (*str != '\0') {
		return 1 + my_strlen(str + 1); //让指针指向下一个字符
	}
	else {
		return 0;
	}
}
int main() {
	char arr[] = "helloworld";
	printf("%d", my_strlen(arr));
	return 0;
}

图解：

练习题3：

求n的阶乘。（不考虑溢出）

//求n的阶乘。（不考虑溢出）
int Fac(int n) {
	if (n <= 2) {
		return n;
	}
	else {
		return n * Fac(n - 1);
	}
}
int main() {
	int n = 0;
	int num = 0;
	scanf("%d", &n);
	num = Fac(n);
	printf("%d\n", num);
	return 0;
}

练习题4：

求第n个斐波那契数。（不考虑溢出）

//求第n个斐波那契数。（不考虑溢出）
int Fib(int n) {
	if (n <= 2) {
		return 1;
	}
	else {
		return Fib(n - 1) + Fib(n - 2);
	}
}

int main() {
	int i = 0;
	int num = 0;
	scanf("%d", &i);
	num = Fib(i);
	printf("%d\n", num);
	return 0;
}

但是我们发现有问题：

1. 在使用Fib这个函数的时候，若我们计算第50个斐波那契数列数字会很耗费时间。
2. 使用上一个问题的函数求 10000的阶乘，程序会崩溃。

为什么呢？

问题1：
因为递归会一直调用自身，很多计算其实一直在重复。

我们就看看，计算第十个斐波那契数列，第三个斐波那契数列计算了几次。

足足有 21 次调用计算第三个斐波那契数列，这就显得很呆。

问题2：
我们之前调用Fac( )函数，计算阶乘。如果你的参数比较大，就会报错： `stack overflow（栈溢出） 这样的信息。

系统分配给程序的栈空间有限，如果出现死循环，或者死递归，这样会一直开辟栈空间，最后导致栈空间耗尽，这样的情况我们称之为栈溢出。

递归总结：

1. 一些问题用递归的形式进行解释，只是因为它比非递归形式更为清晰。
2. 非递归也可以实现功能，可以提高程序执行效率，就是代码的可读性稍差点。