函数

函数是什么？

库函数
自定义函数

函数的参数

实际参数
形式参数

函数的调用

传值调用
传址调用
函数的嵌套调用和链式访问

函数的声明和定义
函数递归
递归与迭代

函数是什么？

数学中我们常见到函数的概念，这是百度百科对函数的定义：子程序.

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

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

库函数

为什么会有库函数？

我们知道在学习C语言编程的时候，总是在一个代码编写完成后迫不及待的想知道结果，但把这几个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定格式打印在屏幕上：（printf）。
在编程过程中会频繁做一些字符串的拷贝工作（strcpy）。
编程中我们也进行数学计算，会进行n^k这样的计算（pow）。
像以上描述的基础功能，他们不是业务性的代码。我们在开发的过程中每个程序猿都可能用到，为了支持可移植性和提高代码的效率，所以C语言的基础库提供了一系列类似的库函数，方便程序员进行软件开发。
常用权威网站： www.cplusplus.com

C语言常用的库函数有：

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

接下来具体看几个库函数：

strcpy

char* strcpy ( char* destination , const char* source );

printf

int printf( const char* format,.... );

memset

void* memset ( void* ptr , int value , size_t num );

注：要想使用库函数，必须包含 #include对应的头文件。

自定义函数

正是因为库函数不能满足现实所有的需求，不能完全应付出现的问题，所以才有了自定义函数的辅佐使用。
自定义函数和库函数一样，有函数名、返回值和函数参数，但是不一样的是内部逻辑由我们来设计，这也给了程序员很大的发挥空间。

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

例如，写一个函数交换两个整形变量的值。

#include <stdio.h>
//创建临时变量形式:
void Swap1(int x,int y){
	int temp = 0;
	temp = x;
	x = y;
	y =temp;
}
//指针形式：
void Swap2(int *px,int *py){
	int temp = 0;
	temp = *px;
	*px = *py;
	*py =temp;
}
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;

函数的参数

实际参数

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

形式参数

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配存储单元），所以叫形参。形式参数当函数调用完成后就自动销毁，不多余占内存空间。因此形式参数只有在函数中才有效。
在函数调用过程中，形参是实参的一份副本（拷贝）。
上面例子中Swap1和Swap2函数的参数x ，y ，px， py都是形式参数。
在main函数中传给Swap1的num1，num2和传给Swap2函数中的&num1，&num2是实际参数。

函数的调用

传值调用

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

传址调用

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

数组名在作为函数的形参的时候，会隐式转换为指针，这个指针指向了数组首元素的地址。

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

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

嵌套调用

#include <stdio.h>
void new_line(){
	printf("hehe\n");
}
void new_new_line(){
	int i = 0;
	for(i = 0;i < 3;i++){
		new_line();
		//在函数定义过程中调用其他函数
	}
}
int main(){
	new_new_line();
	return 0;
}

链式访问
把一个函数的返回值作为另一个函数的参数

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

函数的声明和定义

函数声明

告诉编译器有一个函数叫什么，参数是什么，返回类型是什么，但具体存不存在无关紧要。
函数的声明一般出现在函数使用之前，要满足先声明后使用，否则会报错：未定义的函数xxx。

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

函数递归

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

递归的两个必要条件：

存在限制条件，当满足这个限制条件的时候，递归便不再执行。
每次递归调用之后越来越接近这个限制条件。

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

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

例子2：
函数实现求字符串长度，不允许创建临时变量

#include <stdio.h>
int my_strlen(const char* str){
	if(*str == '\0'){
		return 0;
	}
	else{
		return 1 + my_strlen(str + 1);
	}
}
int main(){
	char* p = "abcdefg";
	printf("%d\n",my_strlen(p));
	return 0;
}

递归与迭代

例子3：
求n的阶乘。

int jie(int n){\
	if(n <= 1){
		return 1;//数学上也定义 0！等于 1
	}
	return jie(n - 1) * n;
}

例子4：
求第n个斐波那契数。

int fib(int n){
	if(n < 2){
		return 1;
	}//else可有可无
	return fib(n - 1) + fib(n - 2);
}

注意：

在使用fib这个函数的时候，如果我们要计算第50个斐波那契数就会特别耗时间。
使用jie函数求10000的阶乘，程序会崩溃。

为什么会如此？
因为递归函数在调用过程中很多计算其实一直在重复，就会特别耗时甚至崩溃，我们想看一下这其中的计算次数，不妨这样实现一下：

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的值就可以得到执行的次数,我们可以知道是一个千万上亿级的数字,所以多次递归中的计算量还是非常大的。

究竟是什么逻辑呢?

在调试jie()函数的时候,如果你的参数比较大,那就会报错:stack overlflow(栈溢出)这样的信息.系统分配给程序栈空间是有限的,但是如果出现了死循环,或者死递归,这样有可能导致一直开辟栈空间,最终产生栈空间耗尽的情况,这样的现象我们成为栈溢出.

那么如何改进呢?

将递归改为非递归.
使用static对象替代nonstatic局部对象.
在递归函数设计中,可以使用static对象替代栈对象的方式减少每次递归调用和返回时产生的nonstatic对象的开销,而且static对象还可以保存递归调用的中间状态,并且可以为各个调用层所访问.

比如:

//求n的阶乘
int jie(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;
}

注:

许多问题以递归形式解释,只是因为它比非递归的形式更为清晰.
但是这些问题的迭代实现往往比递归实现效率要高,虽然代码的可读性稍微差一点.
当一个问题相当复杂,难以用迭代实现,此时递归实现的简洁性便可补偿它所带来的运行时开销.

最后推荐几个函数递归的经典题目,有兴趣的朋友可以深入研究一下:

汉诺塔问题
青蛙跳台阶问题

[C]第三章--函数

函数