C语言初阶——函数

在上一篇文章里，我们学习了分支与循环的，在这一片文章里C语言中另一位重磅角色——函数，就要登场了。本章只要介绍函数的基本使用和递归。

1. 函数是什么
2. 库函数
3. 自定义函数
4. 函数参数
5. 函数调用
6. 函数的嵌套调用和链式访问
7. 函数的声明和调用
8. 函数递归

1.函数是什么？

说到函数，想必大家都不陌生。特别是对于我们理工科的同胞们，我们的学习生涯永远离不开函数。但是，你了解过C语言中的函数吗？
维基百科中对函数的定义：子程序
在计算机科学中，子程序是一个大型程序中的部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具有相对的独立性。
一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
我们应该能够感受到，C语言中的函数与我们数学中的函数还是有很大的相似相的。在这里我们可以形象的将函数比作一个工厂，我们把原材料放入工厂，工厂内部就会进行加工，得到产品。那么C语言中又有哪些函数呢？

2. C语言中函数的分类：

1.库函数
2.自定义函数

2.1库函数

为什么会有库函数？
如果现在让你造汽车，你会怎么做？一辆汽车内部有数万个零件，你打算一个一个地生产吗？我想你肯定不会，因为我们完全可以购买别人生产好的零件，然后进行组装。这样既可以提高我们的生产效率，也使得我们的生产更加规范化，C语言中的库函数就像一个个生产零件的工厂。
在学习C语言编程的时候，我们总是在一个代码完成之后迫不及待的想知道结果，想把这个结果打印到屏幕上看看、这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上，也就是printf。在编程过程中，我们会频繁地做一些字符串的拷贝工作，这里就用到库函数:strcpy。在编程时我们有时候也需要计算，例如计算n的k次方，这里我们就会用到pow函数。
像上面我们描述的基础功能，他们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，于是，为了支持可移植性和提高程序的效率，C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
库函数那么重要，那么我们该怎样去学习它们呢？
我在这里给大家推荐这个网站：http://www.cplusplus.com/

所有的库函数，及每个库函数的使用方法我们都可以在这个网站里面找到，建议大家收藏，并且时不时的学习，积少成多，这样我们的C语言水平就能够不断地提高。
C语言常用的库函数有：

1.IO操作符
2.字符串操作符
3.内存操作符
4.时间/日期函数
5.数学函数
6.其他库函数

注:对于库函数必须知道的一个秘密就是：使用库函数，必须包含**#include**对应的头文件。比如，要使用输入输出函数就必须，#include<stdio.h>。相应的库函数就引用相应的头文件。

2.2 自定义函数

如果库函数就能够干所有的事情，那还要我们程序员干什么？所以个人认为学好库函数是我们的基本功，而更加重要的是我们要学会自定义函数，正所谓，核心技术是买不来的，我们要打造我们的自主生产力 !
自定义函数和库函数一样，有函数名，返回类型和函数参数，但是不一样的是这些都是我们自己来设计，这就给了我们很大的发挥空间。
函数的组成：

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

我们举两个栗子：

1. 写一个函数找出两个整数中的最大值，代码如下：

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

2.写一个函数交换两个整型变量的内容

#include<stdio.h>
//函数1
void Swap1(int x, int y)
{
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}
//函数2
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);
	Swap2(num1, num2);
	printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
	return 0;
}

程序结果如下：
在这里我们一下子写了两个函数，我想学到这里，大部分同学会写出上面的第一个函数，然后自信满满的以为，自己写的代码天衣无缝。但是结果······

哈哈，诸君莫慌，且听我慢慢道来~

3.函数的参数

3.1实际参数(实参)

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

3.2形式参数(形参)

形式参数是指函数名后括号中的变量，因为形式参数只有在函数调用的过程中才实例化(分配内存单元)，所以叫形式参数。形式参数当函数调用完成之后就自动销毁了，因此形式参数只有在函数中有效。
看到这里，我想大家或许已经明白个大概了吧。下面让我给大家详细解读：
你想呀，我们在函数调用的时候确实是把实参num1和num2的值传递给了形参x和y,这一点是没有任何问题的。然后我们在函数内部，也确实是把形参x和y的值进行了调换。然后，我们就自以为是的以为num1和num2的值也发生了调换。其实，真相就是我们仅仅只是交换了形参x和y的值，实参则不为所动。

那既然这样，我们就对num1和num2两个实参本身进行操作，这样不就行了吗？在第一篇文章里，我们曾经讲到过指针的概念，指针说白了就是内存地址。哈哈，正所谓，跑得了和尚跑不了庙，我们直接找到num1和num2的地址将其交换。具体的函数我已经在上面写好了，大家慢慢品味。

4.函数的调用

4.1传值调用

函数的形参和实参分别占有不同的内存块，对形参的修改并不会影响实参。

4.2传址调用

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

5.函数的嵌套调用和链式访问

函数和函数之间是可以有机结合的。

5.1嵌套调用

#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;
}

这样我们就成功的打印了3行hehe

5.2链式访问

把一个函数的返回值作为另一个函数的参数，我们举两个栗子：

#include<string.h>
#include<stdio.h>
int main()
{
	char arr[20] = "hello";
	int ret = strlen(strcat(arr, "bit"));
//有关函数的使用大家可以去上面我说的那个网站，这样就可以锻炼自己的能力，而且记忆会更加深刻
	printf("%d\n", ret);//结果是8
	return 0;
}

#include<stdio.h>
int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	//结果是:在屏幕上打印4321
	//注:printf函数的返回值是打印在屏幕上的字符个数
	//首先我们打印数字43，屏幕上有2个数字，4和3，于是打印2,2只有一个字符，于是再打印1
	return 0;
}

6 函数的声明和定义

6.1函数声明

1.告诉编译器，有一个函数它叫什么，函数参数是什么，返回类型是什么。但是这个函数具体是不是存在，函数声明是决定不了的。
2.函数的声明一般出现在函数的使用之前，要满足先声明后使用。
3.函数的声明一般要放在头文件中，我们可以在test.c中放函数的声明

6.2 函数定义

函数的定义是指函数的具体实现，交代函数的功能实现，我们可以在test.c中放置函数的实现，在后面我还会写三子棋和扫雷这两个好玩的游戏，像这样比较长的代码，我们最好能够分模块来写。

7.函数递归

7.1什么是递归？

从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的是：从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的是：从前有座山，山里有座庙，庙里有个老和尚，老和尚在给小和尚讲故事，讲的是：······你感受到递归的魅力了吗？
在C语言中，程序调用自身的编程技巧叫做递归(recursion)，递归作为一种算法在程序设计语言中广泛应用，一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于:把大事化小

7.2递归的两个必要条件

1.存在限制条件，当满足这个限制条件的时候，递归不在继续。
2.每次递归调用之后越来越接近这个限制条件。
在我们写递归函数的时候一定要注意这两点，不然受苦受难的就会是你心爱的电脑！
7.2.1 递归游戏1:
接受一个无符号整型，按照顺序打印它的每一位，给我们一个数字，比如：12345，我们将它的每一位一次打印出来：1 2 3 4 5，就像这样。
代码：

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

7.2.2递归游戏2:
编写函数不允许创建临时变量，求字符串的长度。
代码：

#include<stdio.h>
int Strlen(const char* str)
{
	if (*str == '\0')
		return 0;
	else
		return 1 + Strlen(str + 1);
}
int main()
{
	char* p = "abcdef";
	int len = Strlen(p);//这里我们传递的是指针变量
	printf("%d\n", len);
	return 0;
}

7.3 递归与迭代

7.3.1 写函数求n的阶乘(不考虑溢出)
代码：

int factorial(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * factorial(n - 1);
}

7.3.2写函数求第n个斐波那契数。(不考虑溢出)
代码：

int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}

但是我们发现有问题：
1.在使用fib这个函数的时候，如果我们要计算第50个斐波那契数字的时候会发现特别耗费时间
2.在使用factorial函数求10000的阶乘的时候程序会崩溃。
Why?
我们发现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，发现是一个很大很大的数

那我们如何改进呢？
在调试factorial函数的时候，如果你的参数比较大，那就会报错：‘stack overflow’（栈溢出）这样的信息。系统分配给程序的空间值有限的，但如果出现了死循环，或者死递归，这样就有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出。
那如何解决上述问题呢？
1.将递归写成非递归
2.使用static对象替代nonstatic局部对象。在递归函数设计的时候，可以使用static对象替代nonstatic局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放nonstatic对象的开销，而且static对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。
比如，下面的代码就采用了，非递归的方式来实现：

//求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;
}

提示：
1.许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
2.但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
3.当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时的开销。
函数我们就先学到这里，大家要反复咀嚼，慢慢消化，下一篇文章我们将进入数组的世界。