【函数:编程小白与C语言正式建交的第二天（打地基阶段2）】

• 函数

函数是什么

数学中f(x)=4*x,f(x)就是一个关于x的函数，在计算机科学中，可以把它定义为一个子程序，子程序是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。无论是哪里的函数，我们都可以把它看作某一个工厂，输入或传入的内容将其看作是原料，输出（传出）的看作是产品。

C语言中函数的分类

• 库函数（库函数的使用时必须必须包含 #include 对应的头文件）

C语言刚出现时，并没有库函数的概念，长期编程过程中，有些功能常常用到，比如：求字符串长度--strlen;比较两个字符串大小---strcmp;打印数据----printf等，在编写过程中，不同的程序员在利用C语言设计一个功能时不会完全相同，这时候对于编程工作就会出现冗余甚至是bug，因此像上面我们描述的基础功能，它们不是业务性的代码，我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

这里我们可以查到每个函数的详细信息：www.cplusplus.com，可以自主查找学习

*我们要想在这条路上走远，就必须培养阅读英文文献的能力

简单的总结，C语言常用的库函数都有：我们在学习过程中慢慢了解即可

IO函数

字符串操作函数

字符操作函数

内存操作函数

时间/日期函数

数学函数

其他库函数

对于如何学会库函数，我们不需要全部记住，但要学会查询工具的使用，以下是一些常用的查询工具：

MSDN(Microsoft Developer Network)

www.cplusplus.com

cppreference.com（英文版）

cppreference.com（中文版）

• 自定义函数

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

函数的组成：

ret_type fun_name(para1, * )

{

statement;//语句项

}

*ret_type 返回类型

*fun_name 函数名

*para1 函数参数

定义函数：

1.根据主函数确定函数名

2.定义函数参数类型，这要由传入实际参数的类型来决定

3.书写函数体中的语句项，这部分是函数实现目标功能的核心

4.确定返回值类型，这还是关乎本函数的功能，取决于你要得到的数据的类型，有些调用函数的目的并非为了得到一个值，此时就不用返回，将其返回值类型定为空即可（即void）

调用函数：

1.确定函数名，最好能代表其功能

2.函数定义部分的参数是形式参数，主函数中的参数是实际参数，形参是实参的一份临时拷贝，形参的改变不会影响实参（形参和实参占据的内存空间是独立的），因此在定义一些无返回值的函数时要注意是否将实际参数定位指针，这样传参后通过指针的变化即可直接实现指针中数据的变化。

• 练习一：比较输入的两整形变量的大小

#include<stdio.h>
int get_max(int x, int y)
{
	return (x > y) ?(x) : (y);//合理运用（）
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d,%d", &a, &b);//对输入设置决定了键盘输入时的规则，此处两数据用逗号隔开，输入时也要用逗号隔开，而非空格
	int max=get_max(a, b);
	printf("两数之中较大的是%d", max);
	return 0;
}

• 练习二：设计一个程序交换输入的两整形变量内容

//1.错误示例
#include<stdio.h>
void swap(int x, int y)
{
	int z = x;
	x = y;
	y = z;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d,b=%d\n", a, b);
	swap(a, b);
	printf("交换后：a=%d,b=%d", a, b);
	return 0;
}

//2.正确示例
#include<stdio.h>
void swap(int* qx, int* qy)//在无需返回值时，注意传参时指针的运用
{
	int z = *qx;
	*qx =*qy;
	*qy = z;
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d,b=%d\n", a, b);
	swap(&a, &b);
	printf("交换后：a=%d,b=%d", a, b);
	return 0;
}

函数参数

• 实际参数

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形

参。

• 形式参数

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内

存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

这里我们对函数的实参和形参进行分析：

 

        这里可以看到 Swap1 函数在调用的时候， x ， y 拥有自己的空间，同时拥有了和实参一模一样的内容。所以我们可以简单的认为：形参实例化之后其实相当于实参的一份临时拷贝。

函数调用

• 传值调用

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

• 传址调用

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

练习一：写一个函数可以判断一个数是不是素数。

//1、打印100-200之间的素数:原版
//素数的定义：如果是素数则这个数只能被1和它本身整除
#include<stdio.h>
int main()
{
int i = 0;
int count = 0;
for (i = 100; i <= 200; i++)
{
	int flag = 1;
	int j = 0;
	for (j = 2; j <= i - 1; j++)
	{
		if (i % j == 0)
		{
			flag = 0;
			break;
		}
	}
	if (flag == 1)
	{
		printf("%d ", i);
		count++;
	}
 }
printf("100-200之间素数的个数是：%d", count);
return 0;
}

//2、打印100-200之间的素数:优化版
//素数的性质：1、偶数一定不是素数；2、若不是素数，则在所有相乘因子对中，一定存在一个因子<=sqrt（i）
//因此优化版只需要判断2到sqrt(i)之间的偶数即可
#include<stdio.h>
#include<math.h>
int main()
{
	int i = 0;
	int count = 0;
	for (i = 101; i <= 200; i+=2)
	{
		int flag = 1;
		int j = 0;
		for (j = 2; j <=sqrt(i); j++)
		{
			if (i % j == 0)
			{
				flag = 0;
				break;
			}
		}
		if (flag == 1)
		{
			printf("%d ", i);
			count++;
		}
	}
	printf("100-200之间素数的个数是：%d", count);
	return 0;
}

//3、判断输入的一个数是不是素数
#include<stdio.h>
#include<math.h>
int is_prime(int n)
{
int j = 0;
	for (j = 2; j <= sqrt(n); j++)
		{
			if (n % j == 0)
			{
				return 0;
			}
		}
	return 1;
}
int main()
{
	int i = 0;
	scanf("%d", &i);
	if (is_prime(i))//要记得给函数传参
	{
		printf("%d是素数",i);
	}
	else
		printf("%d不是素数", i);
 return 0;
}

练习二：写一个函数判断一年是不是闰年。

//1、打印1000-2000之间的闰年年份
//闰年判断方法：1、能被4整除但不能被100整除；2、能被400整除
#include<stdio.h>
int main()
{
	int year = 0;
	for (year = 1000; year <= 2000; year++)
	{
		if (year % 4 == 0)//两个并列的if 语句用于判断一个结果有多种方法
		{
			if (year % 100 != 0)
			{
				printf("%d  ",year);
			}
		}
		if (year % 400 == 0)//这里如果用else if，则一旦进入了第一个if 就不会再进入else if 进行判断！！if嵌套使用时要注意这个问题
			printf("%d", year);
	}
	return 0;
}

//2、优化方法，直接使用逻辑操作符
#include<stdio.h>
int main()
{
	int year = 0;
for (year = 1000; year <= 2000; year++)
	{
	if((year%4==0&&year%100!=0)||(year%400==0))
		printf("%d ", year);
	}
	return 0;
}

//3、利用函数判断某一年是不是闰年
#include<stdio.h>
int is_leap_year(int n)
{
	if ((n % 4 == 0 && n % 100 != 0) || (n % 400 == 0))
		return 1;
	else
		return 0;
}
int main()
{
	int year = 0;
	scanf("%d", &year);
	if(is_leap_year(year))
	printf("%d ", year);
	
	return 0;
}

练习三：写一个函数，实现一个整形有序数组的二分查找。

//1、对一个整形有序数组实现二分查找
#include<stdio.h>
int main()
{
	int arr[] = { 5,6,12,33,56,59,78,99 };
	int k = 12;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;//每次循环mid的值都在变化，因此要把它写进循环体！！！
		if (k < arr[mid])//整型能表示数据的大小是有限制的，left+right的大小可能会因为大于整型变量所容纳的最大数值而溢出，最终导致求得mid不准确
		{
			right = mid-1;
		}
		else if (k > arr[mid])
		{
			left = mid+1;
		}
		else 
		{
			printf("找到了，下标是：%d", mid); 
		break;
		}
		
	}
	if (left > right)
		printf("找不到");
		return 0;
}

//2、利用函数实现对一个整形有序数组实现二分查找
#include<stdio.h>
int binary_search(int arr[], int k, int sz)
{
int left = 0;
int right = sz - 1;
while (left <= right)
{
	int mid = left + (right - left) / 2;//每次循环mid的值都在变化，因此要把它写进循环体！！！
	if (k < arr[mid])//整型能表示数据的大小是有限制的，left+right的大小可能会因为大于整型变量所容纳的最大数值而溢出，最终导致求得mid不准确
	{
		right = mid - 1;
	}
	else if (k > arr[mid])
	{
		left = mid + 1;
	}
	else
	{
		return mid;
	
	}

}
if (left > right)
return -1;//因为返回的下标有0，这里不用返回0，1作为是否找到的区分，而用-1和其它
}

int main()
{
	int arr[] = { 5,6,12,33,56,59,78,99 };
	int k = 59;
	int sz = sizeof(arr) / sizeof(arr[0]);//为什么不在函数内定义，sz呢？因为数组传参时为了避免重建变量时内存空间的浪费，因此会自动将数组第一个元素的地址传过去
	if (binary_search(arr, k, sz)==-1)//此时定义的arr[]实际上是一个指针变量，而我们之前说过指针变量的大小是4/8字节，此时将无法实现二分查找的功能
		printf("找不到！");//因此，我们要在原函数内定义数组元素并将其作为函数参数一并传参
	else
		printf("找到了，下标是：%d", binary_search(arr, k, sz));
	
	return 0;
}

练习四：写一个函数，每调用一次这个函数，就会将 num 的值增加1。

//写一个函数，每调用一次这个函数，就会将 num 的值增加1
 //1、法一：
#include<stdio.h>
int Add(int n)
{
	n++;
	return n;//但是不能直接return n++;因为此时会先返回n，再加1，这个时候就不能实现功能，但是return ++n;是可以的
}
int main()
{
	int num = 0;
	num = Add(num);
	printf("%d \n", num);
	num = Add(num);
	printf("%d \n", num);
	num = Add(num);
	printf("%d \n", num);

	return 0;
}


 //2、法二：当实体本身的值发生改变时，最好用这种方法
#include<stdio.h>
void Add(int* n)
{
	(*n)++;
	
}
int main()
{
	int num = 0;
	Add(&num);
	printf("%d \n", num);
	 Add(&num);
	printf("%d \n", num);
	 Add(&num);
	printf("%d \n", num);

	return 0;
}

*布尔类型：像char，int,short,long,long long ,float,double这些数据类型其实是C语言的内置类型，在C99版本中出现了一种新的数据类型叫做，布尔类型 （bool）,用来表示真假的变量，例：bool flag =true;其实可以把它看作是给整形0，1做了一个封装。其大小是1个字节。

#include <stdbool.h>//用布尔类型定义函数返回值求素数
bool is_prime(int n)
{
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return false;
		}
	}
	return true;
}
int main()
{
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		if (is_prime(i))
		{
			printf("%d ", i);
		}
	}

	printf("%d\n", sizeof(bool));

	return 0;
}

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

• 嵌套调用：

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。函数可以嵌套调用，但是不能嵌套定义

//！！！以下属于函数嵌套定义，为错误写法！！！！
int Add(int x, int y)
{
 int Sub(int x, int y)
{
	return x - y;
}
 return x + y;
}

int main()
{

	return 0;
}

• 链式访问：

把一个函数的返回值作为另外一个函数的参数。前提是有返回值。

#include <string.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	int len = strlen("abcdef");//正常思路
	printf("%d\n", len);


 #include<stdio.h>
 #include<string.h>//链式访问思路
 int main()
 {
     printf("%d\n", strlen("abcdef"));//strlen()返回的数值类型是字符串的长度，是整形
     printf("%d", printf("%d", printf("%d", 43)));//printf函数的返回值是打印在屏幕上字符的个数
   return 0;
 }

*几种错误辨析：

//函数不写返回值的时候，默认返回类型是int
Add(int x, int y)//有结果，不推荐这种写法，不规范，没有返回值类型
{
	return x + y;
}

int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	printf("%d\n", c);
	return 0;
}

int Add(int x, int y)//不推荐，定义了返回值类型却不反回
{
	printf("hehe\n");
}//此代码在一些编译器上返回的是函数中执行过程中最后一条指令执行的结果
int main()
{
	int a = 10;
	int b = 20;
	int c = Add(a, b);
	printf("%d\n", c);
  return 0;
}

void test()
{
	printf("hehe\n");
}
int main()
{
	test(100);//不推荐的
	test();
	return 0;
}


void test(void)//如果明确不想接收参数
{
	printf("hehe\n");
}
int main()
{
	test(100);//不推荐的
	test()
	return 0;
}

另外：明确的说明：main函数不参需要数，但本质上main函数是有参数的

int main(void)
{
	return 0;
}

//main函数有3个参数，后期提到要知道
int main(int argc, char* argv[], char *envp[])
{
	return 0;
}

函数的声明和定义

• 函数声明：

1、告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数

声明决定不了。书写格式：函数返回类型 函数名（函数参数），例如：int  Add(int ,int );

当然为了和函数的定义相匹配参数部分也可以把定义的参数名写出来，如int  Add(int x,int y)。

2、函数的声明一般出现在函数的使用之前。要满足先声明后使用。

正常的声明定义：

*错误提醒1：定义在函数使用之前时，无声名也没有问题，但定义在函数使用之后时，无声明虽然也能运行，但编译器会报警告

*错误提醒2：有声明无定义，声明本身只是起到一个提示给信息的作用，真正能实现函数功能的是函数的定义，因此，当没有定义函数时，程序功能自然不能实现。

3、函数的声明一般要放在头文件中的

• 函数定义：

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

*为了实现模块化管理，我们通常把函数声明放在头文件（.h）里，而把函数定义放在另一个源文件（.c）中，这样不仅仅能够为多人协作的项目提供便利条件。

        模块化的好处还体现在方便于商用，例如：一公司在写一个项目时，想要实现一种功能，需要购买，恰好我们会写，我们想要出售给他们时，只是想要出售功能，并不想把包含有函数定义的源文件出售（防止抄袭等版权问题），此时我们就可以把函数的定义单独存放于一个源文件，函数的声明存放于一个单独的头文件，并且在这个为项目属性页里将配置类型改静态库（.lib）,应用之后编译我们就生成了这个项目的静态库，这个静态库里就包含了我们自己写的函数的功能（但打开这个.lib文件时会发现是一堆乱码，因此在能为对方提供功能的同时也可以很好的保护我们的源码）。我们会把这个静态库以及头文件卖给公司，而公司在项目中应用这个功能时，只需要根据在开头引入我们的静态库【格式：#pragma comment(lib,"静态库名称.lib") ；例如：#pragma comment(lib,"add.lib")】和头文件，就可以正常使用里面的功能。

函数递归

什么是递归？

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

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

递归的两个必要条件

1/存在限制条件，当满足这个限制条件的时候，递归便不再继续。

2/每次递归调用之后越来越接近这个限制条件

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

//例如：
//输入：1234,要求输出1 2 3 4
#include <stdio.h>
void print(unsigned int x)//无符号整形是unsigned int ,不是unsigned
{
	if (x > 9)
	{
		print(x / 10);
	}
	printf("%u", x % 10);//注意此处不是else
}
int main()
{
	unsigned  int a = 0;
	scanf("%u", &a);//%d 是打印有符号的整数(会有正负数),%u 是打印无符号的整数
	print(a);
	return 0;
}

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

//求字符串的长度。常规写法如下，这个时候是需要创建变量的
#include<stdio.h>
int my_strlen(char* sr)
{
	int count = 0;
	while (*sr != '\0')
	{
		count++;
		sr++;
	}
	return count;
}
int main()
{
	char arr[10] = { 0 };//要保证创建的数组能放得下你输入的字符
	scanf("%s", &arr);
	int len = my_strlen(arr);
	printf("输入字符串的长度是：%d", len);
	return 0;
}

//编写函数不允许创建临时变量，求字符串的长度。
//求字符串的长度，即模拟实现strlen
#include<stdio.h>
int my_strlen(char* sr)
{
	if (*sr != '\0')
	{
		return 1 + my_strlen(sr + 1);
	}
	else
		return 0;//这里要用else
}
int main()
{
	char arr[] = { 0 };
	scanf("%s",& arr);
	int len = my_strlen(arr);
		printf("输入字符串的长度是：%d", len);
	return 0;
}

递归与迭代

迭代：可以把它理解成除递归外的其他方式，循环就是一种迭代，但不能说迭代就是循环

下面通过两个联系来理解递归与迭代的用法：

• 练习一：求n的阶乘。（不考虑溢出）

//非递归的方式求n的阶乘
int fac(int n)
	{
		if (n >=1)
		{
			int i = 0;
			int ret = 1;
			for (i = 1; i <= n; i++)
			{
				ret *= i;//ret=ret*i
			}
			return ret;
		}
		else
			return 1;
	}
#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);//这里不需要\n，缓冲区本身就有
	int ret = fac(n);
	printf("ret=%d", ret);
	return 0;
}

//递归的方法求阶乘
int fac(int n)
{
	if (n >= 1)
	{
		return n * fac(n - 1);
	}
	else
		return 1;
}

#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);//这里不需要\n，缓冲区本身就有
	int ret = fac(n);
	printf("ret=%d", ret);
	return 0;
}

• 练习二：求第n个斐波那契数。（不考虑溢出）

//求n斐波那契数
//斐波那契数列：1 1 2 3 5 8 13 21 34 55 ...从第三个数开始，每个数是前两个数之和
//递归方法

int count = 0;
int Fib(int n)
{
	
	if (n ==3)
	
		count++;
	
	if (n >= 3)
	{
		
		return Fib(n-1) + Fib(n - 2);
	}
	else
		return 1;
}
#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("ret=%d\n", ret);
	printf("%d", count);
	return 0;
}
40
39    38
38    37    37    36
37 36 36 35 36 35 35 34
...越往下走会发现有越来越多的重复运算

//迭代方法
int Fib(int n)
{
	int c= 1;
	int a = 1;
	int b = 1;

	while (n >= 3)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}
#include<stdio.h>
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = Fib(n);
	printf("ret=%d\n", ret);
	return 0;
}//没有重复的运算，即使算很大的数也非常快

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

那如何解决上述的问题：

1. 将递归改写成非递归。

2. 使用 static 对象替代 nonstatic 局部对象。在递归函数设计中，可以使用 static 对象替代nonstatic 局部对象（即栈对象），这不 仅可以减少每次递归调用和返回时产生和释放 nonstatic 对象的开销，而且 static 对象还可以保存递归调用的中间状态，并且可为各个调用层所访问。

提示：

1. 许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。

2. 但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。

3. 当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

函数递归的几个经典题目（后期补充）：

1. 汉诺塔问题

2. 青蛙跳台阶问题