函数——也叫子程序

函数

C语言中的函数，也叫子程序，由一或多个语句块构成，用于完成特定任务，具有独立性。一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
C语言中的函数分为两类，一类是库函数，一类是自定义函数。

库函数

如果我们每一个人都写一个类似的代码，不仅代码冗杂而且效率低下，且没有一个标准，因此便有了库函数的存在，C语言提供把常用功能写成函数集成为库。C语言标准规定了库函数的标准，例如strlen这个常用函数，C语言规定了这个函数的函数名（strlen），参数const char* str，返回类型int，功能是求str指向的字符串的长度，因为内部细节和实现方法由编译器提供（gcc/微软）所以会有差异，但是在功能上是没有区别的

库函数的学习

库函数是声明在头文件中的，例如与io相关的函数声明在了stdio.h这个头文件中，常用的库函数由IO函数，字符串操作函数，字符操作函数，内存操作函数，时间日期函数，数学函数，其他库函数，学习库函数要学会查阅文档，这里介绍几个常用库函数的学习方法

学习文档可以了解到，这个函数的功能是拷贝字符串，拷贝由源指向的C字符串到目标所指向的数组中，包含结束时候的null（null小写指的是\0）；形参dest：指针指向的要被覆盖的空间的地址，source：要被拷贝的C string，函数的返回值是dest为目标空间的地址

1.练习使用strcpy这个函数

//1.能把arr1中的abcdef拷贝到arr2中
#include
#include
int main()
{
	char arr1[] = "abcdef";
	char arr2[20] = { XXXXXXXXXXX };
	strcpy(arr2, arr1);
	printf("%s", arr2);
	return 0;
}

同时，这个代码通过调试可以看到\0也被拷贝进来

这个函数的作用是填充内存块，设置ptr指向内存块的前num个bytes为指定的value，ptr：指针指向的要填充的内存块的地址，num为要被改为value值的字节数，该函数返回一个ptr

memset代码测试

//2.改hello world为hello ccccc
#include
#include
int main()
{
	char arr1[] = "hello world";

	memset(arr1+6,'c',5);
	printf("%s", arr1);
	return 0;
}

自定义函数的学习

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

函数的组成

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

实现get_max函数

//3.get_max
#include
int get_max(int x, int y)
{
	return x > y ? x : y;
}
int main()
{
	int a = 5;
	int b = 10;
	int max = get_max(a, b);
	printf("%d", max);
	return 0;
}

//4.写一个函数可以交换两个整形变量的内容
#include
void swap(int* x, int* y)
{
	int tmp = 0;
	tmp = *x;
	*x = *y;
	*y = tmp;
}
int main()
{
	int a = 5;
	int b = 10;
	swap(&a, &b);
	printf("a=%d b=%d", a, b);
}

这里不演示错误写法，直接给出结论当实参传给形参的时候，形参是实参的一份临时拷贝，对形参的修改不会影响实参
通过交换功能函数的实现可以得出关于函数的一些结论

函数参数和调用

1 .实际参数（实参）：
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形
参。
2 .形式参数（形参）：
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内
存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
1 .传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
2 .传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以通过指针让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

代码练习

打印素数

//5.打印100~200之间的素数

#include
#include
int is_prime(int n)
{
	int i = 0;
	for (i = 2; i < sqrt(n); i++)
	{
		if (n % i == 0)
			return 0;
	}
	return 1;
}
int main()
{
	int n = 0;
	for (n = 100; n <= 200; n++)
	{
		int ret = 0;
		 ret=is_prime(n);
		if (ret == 1)
		{
			printf("%d ", n);
		}
	}
	return 0;
}

判断闰年

//6.判断闰年,打印1000~2000年之间的闰年
#include
int is_leapyear(int i)
{
	return (i % 400 == 0) || ((i % 4 == 0) &&( i % 100 != 0));
}
int main() 
{
	int i = 1000;
	for (i = 1000; i <= 2000; i++)
	{
		if(is_leapyear(i)==1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}

二分查找函数

#include
int binary_search(int* arr, int sz, int n)//也可以写成int arr[]，但不是本质，这里不会创建这么大的数组
//数组在传参的时候，传递不是整个数组
//传递是数组首元素的地址
{
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] > n)
		{
			right = mid - 1;
		}
		else if (arr[mid] < n)
		{
			left = mid + 1;
		}
		else
			return mid;
	}
	return -1;
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9 };
	int n = 4;
	int sz = sizeof(arr )/sizeof(arr[0]);
	int ret = binary_search(arr, sz, n);//二分查找，如果找到了就返回下标，如果没有就返回-1
		if (ret == -1)
		{
			printf("找不到");
		}
		else
		{
			printf("下标为：%d", ret);
		}
		return 0;
}

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

1.嵌套调用

注：函数可以嵌套调用但是不可以嵌套定义

2.链式访问

把一个函数的返回值作为另外一个函数的参数，注意链式访问的执行顺序

int main()
{
	//int len = strlen("abcdef");
	//printf("len = %d\n", len);

	printf("len = %d\n", strlen("abcdef"));

	printf("%d", printf("%d", printf("%d", 43)));
//打印4321
	return 0;
}

函数的声明和定义

int Add(int ,int);//函数的声明，形参叫什么可以忽略
int main()
{
int sum=Add(a,b);//函数的调用
}
int Add(int x,int y)//函数的实现
{
return x+y;
}

应用静态库

如果你想把函数的实现写在main下面的话，上面一定要写函数的声明，否则Warnning：“Add”未定义，原因是test.c——>编译链接——>test.exe，编译就是扫描代码，当扫到Add时没有发现这个函数报出警告，所以main函数之前就要对Add进行声明，声明要包括函数名，参数和返回类型
在企业中写代码，往往要声明和定义分离，例如我们写一份实现加法功能的代码，在add.c这个文件中写函数的实现，在add.h这个文件中写函数的声明，声明和定义的分离的好处是想让别人用代码但不想让源码暴露出来，可以将我们的.c文件编译成静态库，我们可以做以下操作
1.项目（add）名称右键，属性，常规，配置类型，静态库，应用。
2.生成解决方案，形成add.lib文件，这个add.lib就是关于函数的实现，可以把add.h和add.lib给别人使用
使用方法：
1.把.h和.lib添加到同一文件夹下
2.把.h放入工程中
3.在自己的test.c中导入静态库

#include "add.h"
//导入静态库
#pragma comment(lib, "add.lib")//lib代表我想在这里加一个静态库，后面写上这个静态库的名字

像printf这样的库函数也是编译放进静态库，用户包含头文件，编译器就会默认帮你导入，因为是静态库所以我们看不到printf的源码但是编译器提供了参考代码

函数递归

什么是递归

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

#include 
int main()
{
  printf("hehe\n");
	main();
	return 0;
}

这个程序会无限打印hehe，最终会挂掉，错误原因是StackOverflow 栈溢出，这是一个错误的程序原因在于没有满足递归的条件

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

用递归解决问题

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

思路：
print(1234)
print(123) 4
print(12) 3 4
print(1) 2 3 4
归的条件是n<9,然后层层返回

void print(int n)
{
	if (n < 9)
	{
		printf("%d ", n);
		return;
	}
	else
	{
		print(n / 10);
		printf("%d ", n % 10);
	}
}
#include
int main()
{
	int n = 0;
	scanf("%d", &n);
	print(n);
	return 0;
}

//这样写更好
void print(int n)
{
	if (n > 9)
	{
		print(n/10);
	}
	printf("%d ", n % 10);
}

2.编写函数不允许创建临时变量，求字符串的长度
（1）创建临时变量的迭代写法

//9.编写函数允许创建临时变量，求字符串的长度
#include
int my_strlen(char* arr)
{
	int count = 0;
	while (*arr != '\0')
	{
		count++;
		arr++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef";
	int sz = my_strlen(arr);
	printf("%d", sz);
	return 0;
}

(2.)不允许创建临时变量的递归写法

思路：
my_strlen(“abcdef”)
1+my_strlen(“bcdef”)
1+1 + my_strlen(“cdef”)
1 + 1+1 + my_strlen(“def”)
1 + 1 + 1 +1+ my_strlen(“ef”)
1 + 1 + 1 + 1 + 1my_strlen(“f”)
1 + 1 + 1 + 1 + 1+1my_strlen(“‘\0’”)
1+字串（1+字串（1+字串（…）））），\0为终止条件

int my_strlen(char* arr)
{
	if (*arr != '\0')
		return 1 + my_strlen(arr + 1);
	else
		return 0;
}
int main()
{
	char arr[] = "abcdef";
	int sz = my_strlen(arr);
	printf("%d", sz);
	return 0;
}

3.求阶乘

//11.求n=5的阶乘
#include
int fac(int n)
{
	if (n > 1)
		return n * fac(n - 1);
	else
		return 1;
}

int main()
{
	int n = 5;
	int x = fac(n);
	printf("%d", x);
	return 0;
}

4.斐波那契数列(递归写法）

//12.斐波那契额数列
//1 1 2 3 5 8 13 21.....
#include
int fac(int n)
{
	if (n > 2)
		return fac(n - 1) + fac(n - 2);
	else
		return 1;
}
int main()
{
	int n = 30;//求第三十个斐波那契
	int f=fac(n);
	printf("%d", f);
	return 0;
}

递归缺陷，层次太深，在这个例子中使用了大量重复运算

迭代写法

int fac(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
		while (n > 2)
		{
			c = a + b;
			a = b;
			b = c;
			n--;
		}

	return c;

}

5.思考题
青蛙跳台阶
汉诺塔…