目录

一.什么是函数

二.C语言中函数分类

库函数

自定义函数

三.函数的参数

 实际参数(实参)

形式参数(形参)

四.函数的调用

传值调用

传址调用

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

嵌套调用

链式访问

六.函数的声明和定义

函数的声明

函数的定义

七.函数递归

什么是函数递归 

递归的两个条件

一.什么是函数 数学中我们常见到函数的概念。但是你了解 C 语言中的函数吗？ 维基百科中对函数的定义： 子程序

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

二.C语言中函数分类

• 库函数
• 自定义函数

库函数 为什么会有库函数？ 1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上(printf), 2.在编程的过程中我们会频繁的做一些字符串的拷贝工作(strcpy), 3. 在编程是我们也计算，总是会计算 n 的 k次方这样的运算(pow), 像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到,为了支持可移植性和提高程序的效率，所以C 语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。 4.那怎么学习库函数呢?这里我们简单的看看： www.cplusplus.com

 

•  它上面还有很多这里就不一一演示了

简单的总结，C语言常用的库函数都有：
IO函数
字符串操作函数
字符操作函数
内存操作函数
时间/日期函数
数学函数
其他库函数

---

列如：

strcpy

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

#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello bit";
	strcpy(arr1, arr2);
	printf("%s", arr1);//hello bit
	return 0;
}

•  %s为打印字符串的格式控制符

memset

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

#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
	char arr[] = "hello bit";
	memset(arr, 'x', 5);
	printf("%sn", arr);//xxxxx bit
	return 0;
}

•  大多数情况下，数组传参其实是传递数组首元素的地址，在后面我会详细演解

注： 但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。 而且我们不需要把全部的库函数记住，但我们需要学会查询工具的使用

MSDN(Microsoft Developer Network) www.cplusplus.com http://en.cppreference.com （英文版） http://zh.cppreference.com （中文版）

• 其中建议使用英文，也有利于提高我们的英语水平

自定义函数 如果库函数能干所有的事情，那还要程序员干什么？ 所有更加重要的是 自定义函数 。 自定义函数和库函数一样，有函数名，返回值类型和函数参数。 但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间 函数组成：

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

我们举一个例子：

写一个函数可以找出两个整数中的最大值

#define _CRT_SECURE_NO_WARNINGS
#include
int get_max(int x, int y)
{
	int z = 0;
	if (x > y)
		z = x;
	else
		z = y;
	return z;//返回z-返回较大值
}

int main()
{
	int a = 10;
	int b = 20;
	//函数的调用
	int max = get_max(a, b);
	printf("max = %dn", max);
	return 0;
}

---

再举一个列子：

写一个函数可以交换两个整形变量的内容

#define _CRT_SECURE_NO_WARNINGS
#include
void Swap(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 10;
	int b = 20;
	printf("交换前：a=%d b=%dn", a, b);//a=10 b=20
	Swap(a, b);
	printf("交换后：a=%d b=%dn", a, b);//a=10 b=20
	return 0;
}

• 函数返回类型的地方写出：void，表示这个函数不返回任何值，也不需要返回
• 但是在实际运行的过程中，得不到我们想要的结果，出现的问题，

•  当我们调试代码的时候，发现a的地址和x的地址不一样，说明开辟了两个空间进行存储，b和y同理

• 实际上这个函数在进行交换的时候，只是把x和y的内容交换了，a和b的内容本身没有改变

 而正确的写法应该是这样的：

#define _CRT_SECURE_NO_WARNINGS
#include
void Swap2(int* pa, int* pb)
{
	int z = 0;
	z = *pa;
	*pa = *pb;
	*pb = z;
}

void Swap1(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 10;
	int b = 20;
	Swap1(a, b);//传值调用
	printf("传值调用：a=%d b=%dn", a, b);//a=10 b=20
	Swap2(&a, &b);//传址调用
	printf("传址调用：a=%d b=%dn", a, b);//a=20 a=10
	return 0;
}

•  其中的Swap2才是正确的函数实现，这里简单的使用了一下指针，后期会说的

三.函数的参数

 实际参数(实参)

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

形式参数(形参)

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

上面 Swap1 和 Swap2 函数中的参数 x ， y ， px ， py 都是 形式参数 。在 main 函数中传给 Swap1 的 num1, num2 和传给Swap2 函数的 &num1 ， &num2 是 实际参数 。

 swap1在被调用的时候，实参传给形参，其实形参是实参的一份临时拷贝,改变形参,不能改变实参

四.函数的调用

传值调用

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

如：Swap1(a, b);//传值调用

传址调用

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

如：Swap2(&a, &b);//传址调用

五.函数的嵌套调用和链式访问 函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。

嵌套调用

#define _CRT_SECURE_NO_WARNINGS
#include
void test3()
{
	printf("hehen");//hehe
}

int test2()
{
	test3();
	return 0;
}

int main()
{
	test2();
	return 0;
}

• 函数可以嵌套调用，但是不能嵌套定义。

链式访问

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

#define _CRT_SECURE_NO_WARNINGS
#include
#include
int main()
{
	int len = strlen("abc");
	printf("%dn", len);

	//链式访问
	printf("%dn", strlen("abc"));
	return 0;
}

---

#include 
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));//4321
    return 0; 
}

• 注：printf函数的返回值是打印在屏幕上字符的个数,所以打印的结果是4321

六.函数的声明和定义

函数的声明

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

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
	int a = 10;
	int b = 20;

	//函数声明一下 - 告知
	int Add(int x, int y);
	int c = Add(a, b);
	printf("%dn", c);
	return 0;
}

//函数的定义
int Add(int x, int y)
{
	return x + y;
}

• 编译器是从上往下进行扫描的，所以需要进行函数声明，如果没有函数声明，编译器会报出函数未定义的错误
• 当然你也可以把函数的定义写前面，这样就不用进行函数声明了

函数的定义

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

以.h为后缀的文件一般包含宏定义，库函数， 函数的声明等等，比如test.h test.h 的内容 放置函数的声明

#ifndef __TEST_H__ #define __TEST_H__ // 函数的声明 int Add ( int x , int y ); #endif //__TEST_H__

• 其中的ifndef和endif我会在后期文件中讲到

---

 以.c为后缀的文件一般包含函数的声明等等，比如test.c

test.c 的内容 放置函数的实现

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

这种分文件的书写形式，在三字棋和扫雷的时候，会被用到

---

七.函数递归

什么是函数递归 

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

比如说：

#define _CRT_SECURE_NO_WARNINGS
#include
int main()
{
	printf("hehen");
	main();
	return 0;
}

•  这也算是一个递归，main函数自己调用自己，会在屏幕上不停的打印hehe,这个递归将会导致栈溢出，Stack overflow

递归的两个条件

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

列1：

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

#define _CRT_SECURE_NO_WARNINGS
#include
void print(unsigned int n)//123
{
	if (n > 9)
	{
		print(n / 10);
	}
	printf("%d ", n % 10);//1 2 3
}

int main()
{
	unsigned int num = 0;
	scanf("%u", &num);//123
	//递归 - 函数自己调用自己
	print(num);//print函数可以打印参数部分数字的每一位
	return 0;
}

• 当输入123的时候 

•  递归其实有一种倒着的思想，先看红色的箭头，再看绿色的箭头，大问题转换成小的问题，再倒着回去

---

列2：

#define _CRT_SECURE_NO_WARNINGS
#include
void test(int n)
{
	if (n < 10000)
	{
		test(n + 1);
	}
}

int main()
{
	int a = 10;
	test(1);
	return 0;
}

• 这个递归是有问题的，会导致栈溢出，因为递归的层次太深了，具体的以后会详细说的
• 在写递归代码的时候：不能写死递归，必须要有跳出条件，每次递归都应该逼近跳出条件，且递归层次不能太深，防止栈溢出

---

列3：

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

#define _CRT_SECURE_NO_WARNINGS
#include
int my_strlen(char* str)
{
	if (*str != '')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

int main()
{
	char arr[] = "bit";
	//['b']['i']['t']['']
	printf("%dn", my_strlen(arr));
	return 0;
}

• 这里简单的使用了一下指针，后面会详细讲的，这个递归的出口是if (*str != '')，它的逼近出口是 my_strlen(str + 1)，有了这两个语句，递归才能结束，

列3

求第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 ); }

• 但是我们发现有问题:在使用 fib 这个函数的时候如果我们要计算第50个斐波那契数字的时候特别耗费时间。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是一个很大的数字，这就说明fib计算第50个斐波那契数字，进行了大量重复计算
• 系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出，并且会报stack overflow的错误

 那如何解决上述的问题：

1.将递归改写成非递归，(推荐使用) 2.使用static 对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代 nonstatic 局部对象（即栈对象），这不仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问 比如，下面代码就采用了，非递归的方式来实现：

#define _CRT_SECURE_NO_WARNINGS
#include
int Fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n>2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);

	printf("%dn", ret);

	return 0;
}

• 非递归的实现，核心就是在于a b c这3个字母的移动，最后的c=a+b,就是我们想要的值

提示： 1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。 2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。 3. 当一个问题相当复杂，难以用迭代实现时，递归实现的简洁性便可以补偿它所带来的运行时开销 ************************************************************************************************************** 函数递归的几个经典题目之 汉诺塔问题 C语言 - 汉诺塔详解(超详细)_wh128341的博客-CSDN博客_c语言汉诺塔 函数递归的几个经典题目之 青蛙跳台阶问题 算法—青蛙跳台阶问题汇总_zhangshk_的博客-CSDN博客_青蛙跳台阶