目录

函数

一、函数是什么？

二、函数的组成

三、C语言中函数的分类

四、函数的参数

五、函数的调用

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

七、函数的声明和定义

八、函数递归

九、总结

---

函数

前面已将初步的了解了函数，这次再更深入的了解一下C语言中的函数。

一、函数是什么？

函数是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性（函数跟其他代码没什么关联，函数可以实现某一个功能，使用时可以直接调用）。

函数一般会有输入参数和返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

二、函数的组成

ret_type fun_name (para1, * )

{

        statement;//语句项

}

• ret_type ： 返回类型
• fun_name ：函数名
• para1    ：函数参数
• 由 { } 括起来的： 函数体

三、C语言中函数的分类

1. 库函数：C语言中提供的函数，可以直接使用。比如输入函数：scanf。
2. 自定义函数：自己创造实现某种功能的函数。

1、库函数

（1）为什么会有库函数？

C语言提供的库函数都是一些使用比较频繁的函数（比如输入输出）。

如果C语言没有提供库函数，那么像输入输出这些功能就要自己实现。可是在开发的过程中每个程序员都可能要用到这些功能，那么在使用的时候每个都要写这些函数来实现同一个功能，这样对开发的效率就会比较低。而且每个人对同一个功能的实现所写的代码逻辑肯定是有所差异的，这样带来的后果就是代码的跨平台性不够好。

为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

（2）C语言常用的库函数：

• IO函数（input / output 输入输出函数）
• 字符串操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

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

（3）这里提供一些学习使用库函数的方法：

cplusplus.com - The C++ Resources Network

http://en.cppreference.com（英文版） 

http://zh.cppreference.com（中文版）

strlen 函数

strlen 函数的使用：

#include
#include

int main()
{
	char ch[] = "abcd";
	int len = strlen(ch);
	printf("%dn", len);
	return 0;
}

运行结果：

使用文档查看 strlen 函数的返回类型为 size_t，其实标准的写法是：

#include
#include

int main()
{
	char ch[] = "abcd";
	//size_t -> unsigned int （无符号整型）
	size_t len = strlen(ch);
	printf("%un", len);
	//%d - 有符号整型
	//%u - 无符号整型
	return 0;
}

 运行结果：

 两种写法其实没什么区别一般也是写第一种，但是第二种才是最标准的写法。

memset 函数

 memset 函数的使用

#include
#include

int main()
{
	char arr[] = "hello world";
	memset(arr, '#', 5);
	printf("%sn", arr);
	return 0;
}

运行结果

 2、自定义函数

如果库函数能干所有的事情，那还要程序员干什么？

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

举几个例子：

（1）写一个函数，找出两个数的较大值并将较大值返回。

#include
//函数定义
int get_max(int a, int b)
{
	int z = 0;
	z = a > b ? a : b;
	return z;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//函数调用
	int max = get_max(a, b); 
	printf("%dn", max);
	return 0;
}

运行结果：

•  函数可以不需要返回值、不需要参数。

 （2）写一个菜单函数。

#include
//void ->不需要返回
void menu()
{
	printf("******   1.play   ******n");
	printf("******   0.exit   ******n");
}
int main()
{
	//调用两次，就会将函数中的内容打印两次
	menu();
	menu();
	return 0;
}

运行结果：

 （3）写一个函数：交换两个整型变量的内容。

• 两个整数交换的步骤：

#include
void Swap(int a, int b)
{
	int temp = 0;
	temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%dn", a, b);
	//交换两个变量
	Swap(a, b);
	printf("交换后：a=%d b=%dn", a, b);
	return 0;
}

运行结果：

 为什么结果没有互换呢？

main函数中Swap(a, b);这里传入的 a 和 b 称为实参，而void Swap(int a, int b)函数中的int a，int b，这里的 a 和 b 称为形参。

当函数调用的时候，实参传给形参，形参其实是实参的一份临时拷贝。所以对形参的修改，不会影响实参。

对代码的修改：

#include
void Swap(int* px, int* py)
{
	int temp = 0;
	temp = *px;
	*px = *py;
	*py = temp;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d b=%dn", a, b);
	//交换两个变量
	Swap(&a, &b);
	printf("交换后：a=%d b=%dn", a, b);
	return 0;
}

运行结果：

 看一下两个函数在内存中的变化：

将变量a、变量b的地址当做实参传给形参（Swap2(&x, &y);），使用指针变量指针变量来存放地址，所以Swap2函数中的参数要使用指针变量来接收a、b的地址。当交换了形参 px 与 py的值，就会交换实参 a 和 b的值。

四、函数的参数

• 函数调用传递参数是实际参数（实参），函数定义接收的参数是形式参数（形参）。
• 形参类型必须与实参类型一致。
• 形参变量名可以与实参变量名：可以相同，也可以不相同。

1、实际参数（实参）

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

#include
//函数定义
int get_max(int a, int b)
{
	int z = 0;
	z = a > b ? a : b;
	return z;
}
int main()
{
	int a = 0;
	int b = 0;
	int max1 = 0;
	int max2 = 0;
	int max3 = 0;
	scanf("%d %d", &a, &b);
	//函数调用
	max1 = get_max(a, b); //变量
	max2 = get_max(30, 50); //常量
	max3 = get_max(10 + 22, get_max(2, 66)); //表达式、函数
	printf("max1 = %dn", max1);
	printf("max2 = %dn", max2);
	printf("max3 = %dn", max3);
	return 0;
}

运行结果：

2、形式参数（形参）：

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

交换两个整型变量的代码中：

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

五、函数的调用

1、传值调用

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

2、传址调用

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

交换两个整型变量的代码中：

• Swap1 是传址调用
• Swap2 是传址调用

3、函数练习

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

#include
#include
int is_prime(int i)
{
	int j = 0;
	for (j = 2; j <=sqrt(i); j++)
	{
		if (i % j == 0)
		{
			return 0;
		}
	}
	return 1; //是素数
}
int main()
{
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		//判断 i 是否为素数，是素数就打印 i
		if (is_prime(i) == 1)
		{
			printf("%d ",i);
		}
	}
	return 0;
}

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

#include
int is_leap_year(int y)
{
	if ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)
	{
		return 1;
	}
	return 0;
}
int main()
{
	int y;
	for (y = 1000; y <= 2000; y++)
	{
		if (is_leap_year(y) == 1)
		{
			printf("%d ", y);
		}
	}
	return 0;
}

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

#include
int binary_search(int* arr, int k, int sz)
{
	int left = 0;
	int right = sz - 1;
	while (left<=right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;//找不到
}
int main()
{
	int arr[] = { 10,20,30,40,50,60,70,80,90,100 };
	int k = 70;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int ret = binary_search(arr, k, sz);
	if (-1 == ret)
	{
		printf("找不到!n");
	}
	else
	{
		printf("找到了，下标为%dn",ret);
	}
	return 0;
}

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

• 方法一：无返回值

#include

void Add(int* p)
{
	*p = *p + 1;
	//也可以写成 ：(*p)++;
}
int main()
{
	int num = 0;
	Add(&num);
	printf("%dn", num);

	Add(&num);
	printf("%dn", num);

	Add(&num);
	printf("%dn", num);

	return 0;
}

• 方法二：有返回值

#include

int Add(int num)
{
	num++;
	return num;
	//也可以写成 ：return ++num;
}
int main()
{
	int num = 0;
	num = Add(num);
	printf("%dn", num);

	num = Add(num);
	printf("%dn", num);

	num = Add(num);
	printf("%dn", num);

	return 0;
}

调用了三次 Add 函数，屏幕最终打印出： 1 2 3。

补充：

函数的类型有两种：

无返回类型：void

有返回类型：char  int   float  double

无返回类型的函数（void）也可以有 return 语句，不返回任何值。

#include
void test1()
{
	return;
}
int main()
{
	test1();
	return 0;
}

如果给 void 类型的函数返回了一个值编译器会报错。

void 类型的函数中如果写了 return 语句，这个函数只执行 return 之前的语句。

#include
void test1()
{
	int n = 5;
	printf("hehen");
	if (5 == n)
	{
		return;
	}
	printf("hellon");
}
int main()
{
	test1();
	return 0;
}

运行结果：

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

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。

1、函数的嵌套调用

#include
void line()
{
	printf("Hello Worldn");
}
void three_line()
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		line();
	}
}
int main()
{
	three_line();
	return 0;
}

代码分析：

定义 line 函数打印 Hello World，现在想要再屏幕上打印三次 Hello World ，再定义一个 three_line 函数，使用 three_line 函数调用三次 line 函数。最后在main函数中调用 three_line 函数。

运行结果：

函数不可以嵌套定义

总结：

函数不能嵌套定义，但是可以嵌套调用。（所有的函数关系都应该是并列的，使用的时候可以互相调用）。

2、函数的链式访问

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

#include
#include
int main()
{
	//求一个字符串的长度
	//代码一：
	int len = strlen("abc");
	printf("%dn", len);

	//代码二：
	printf("%dn", strlen("abc"));
	return 0;
}

运行结果：

两种写法运行的结果是相同的。

 代码二是将 strlen 函数的返回值，作为 printf 函数的第二个参数（双引号引起来的是 printf 函数的第一个参数）。这就是函数的链式访问。

练习：

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

  printf 函数：

代码分析：

第三个 printf 函数先打印 43，再将打印的个数（2）返回给第二个 printf 函数（第二个 printf 函数输出 2），再将第二个函数打印的个数（1）返回给第一个 printf 函数（第一个 printf 函数输出 1）。最后在屏幕上打印出 4321。

运行结果

七、函数的声明和定义

1、函数的声明

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

一般在写函数的时候都是将函数写在main函数前面，但是很多书中都是将自定义函数写在main函数后面。如果将自定义函数写在了main函数后面，再去使用这个函数的时候虽然代码可以正常执行但是编译器会报警告。

 如果要消除警告，有两种方法：

1. 将自定义函数写在main函数之前。
2. 在main函数前先声明自定义函数。

#include
//函数的声明
//int Add(int a, int b); 
int Add(int ,int);

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int ret = Add(a, b);
	printf("%dn", ret);
	return 0;
}
//函数的定义
int Add(int a, int b)
{
	return a + b;
}

2、函数的定义：

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

补充：

在开发的过程中是有多个文件的：

• .h ：头文件
• .c ：源文件

为什么要有头文件：

1. 单纯的使用源文件，组织项目结构的时候，项目越大与复杂的时候维护成本也就越高；
2. 产生头文件（.h),可以在组织项目结构的时候，减少大型项目的维护成本问题。
3. 头文件都是要被多个源文件包含；（也有可能会被重复包含-->会导致程序编译效率降低）
4. 解决头文件可能会被重复包含的方法：在头文件开头写入：#pragma once

c语言库函数的头文件使用<>，自定义函数的头文件使用 " "；

（1）.h ：头文件：要写入的内容：

• #pragma once
• C语言中调用库函数的头文件；
• 所有变量的声明；
• 所有函数的声明；
• 宏定义

（2）.c ：源文件：要写入的内容：

• 函数的实现
• 变量的定义

八、函数递归

1、什么是递归

• 程序调用自身的编程技巧称为递归
• 函数自己调用自己就是递归

史上最简单的递归

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

 这段代码main函数自己调用自己，但是会死递归，最后导致程序崩溃。

程序并不是正常的停止， main函数死递归导致程序崩溃，程序才停止的。这种写法其实是错误。

系统分配给程序的栈空间是有限的，但是如果出现了死循环，或者（死递归），这样有可能导致一 直开辟栈空间，最终产生栈空间耗尽的情况，这样的现象我们称为栈溢出 。

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

递归的主要思考方式在于：把大事化小。

2、递归的两个必要条件

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

3、练习

（1）接受一个整型值（无符号），按照顺序打印它的每一位。

         例如： 输入：1234，输出 1 2 3 4.

#include
// 1234
// 1 2 3 4
//Print(1234)
//Print(123) 4
//Print(12) 3 4
//Print(1) 2 3 4
void Print(unsigned int n)
{
	//n > 9 -> n 如果不是一位数就可以一直进行除10操作
    //直到 n 是一位数就可以将它打印出来
	if (n > 9)
	{
		Print(n / 10);
	}
	printf("%u ", n % 10);
}
int main()
{
	unsigned int num = 0;
	scanf("%u", &num);
	Print(num);
	return 0;
}

（2）编写函数求字符串的长度。

#include
int My_strlen(char* s)
{
	int count = 0;
	while (*s!='')
	{
		s++; //地址加 1 指向下一个字符
		count++;
	}
	return count;
}
int main()
{
	char str[] = "abc";
	int len = My_strlen(str);//传过去的是数组首元素的地址
	printf("%dn", len);
}

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

#include
//"abc"
//My_strlen("abc")
//1 + My_strlen("bc")
//1 + 1 + My_strlen("c")
//1 + 1 + 1 +My_strlen("")
//1 + 1 + 1 + 0 =3
int My_strlen(char* s)
{
	if (*s == '')
		return 0;
	else
		return 1+My_strlen(s+1);
}
int main()
{
	char str[] = "abc";
	int len = My_strlen(str);//传过去的是数组首元素的地址
	printf("%dn", len);
}

4、递归与迭代

有些题使用递归的方式可以解决，使用非递归（迭代）的方式也可以解决。

（1）求 n 的阶乘

• 方法一（循环）：

#include
int main()
{
	int n = 0;
	int i = 0;
	int ret = 1;
	scanf("%d",&n);
	for (i = 1; i <= n; i++)
	{
		ret *= i;
	}
	printf("%dn", ret);
	return 0;
}

• 方法二（递归）：

#include
int fac(int n)
{
	if (n <= 1)
		return 1;
	else 
		return n * fac(n - 1);
}
int main()
{
	int n = 0;
	int ret = 0;
	scanf("%d", &n);
	ret = fac(n);
	printf("%dn", ret);
	return 0;
}

（2）求第n个斐波那契数。

斐波那契数：1 1 2 3 5 8 13 21 34 55 ……

• 方法一（递归）：

#include
int fib(int n)
{
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}
int main()
{
	int n = 0;
	int ret = 0;
	scanf("%d", &n);
	ret = fib(n);
	printf("%dn", ret);
	return 0;
}

这种算法虽然可以计算出结果，但是计算效率太低它会大量的计算重复的值。

在计算第40个斐波那契数，第3个斐波那契数被计算了 39088169次。

虽然递归代码比较简洁，但是有些题并不适合使用递归求解。

• 方法二（循环）:

#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;
	int ret = 0;
	scanf("%d", &n);
	ret = fib(n);
	printf("%dn", ret);
	return 0;
}

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

九、总结

详细介绍了C语言中函数，C语言中的函数很重要，但是有些内容理解起来还是比较困难。

编程需要多动手写代码、多做题、多练习。练的多了自然就懂了。