1）在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method, subprogram, callable unit），是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。

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

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

1）库函数

如：printf scanf strlen

早期的C语言没有库函数——代码冗余—开发效率低—不标准

把常用的功能实现成函数——集成为库，由C语言直接提供。

C语言标准，就可以规定库函数的标准——

如：int strlen（const char* srt）/ 功能：求str指向的字符串长度

为什么会有库函数？

1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。

2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。

3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。

像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

那怎么学习库函数呢？

简单的总结，C语言常用的库函数都有：

IO函数

字符串操作函数

字符操作函数

内存操作函数

时间/日期函数

数学函数

其他库函数

我们参照文档，学习几个库函数：

memset函数

//memory set——memset函数—内存设置
//size_t——unsigned int
sizeof()返回的值类型是size_t——就是无符号整形—%u
#include<string.h>//memset头文件
int main()
{
	char arr[] = "hello computer";
	//把前面的hello改成xxxxx
	memset(arr, 'X', 5);
	//第一个参数—设置空间的地址传过去
	//第二个参数—设置值
	//第三个参数—多少个字节需要设置
	printf("%s\n", arr);//XXXXX computer
	return 0;
}

如何学会使用库函数？

需要学会查询工具的使用：

MSDN(Microsoft Developer Network)

www.cplusplus.com

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

英文很重要。最起码得看懂文献。

strcpy函数

//strcpy函数
#include<stdio.h>
#include<string.h>//strcpy函数头文件
int main()
{
	char arr1[] = "abcdef";//a b c d e f \0
	//char arr2[20] = { 0 };// 0 0 0 0 0 ~0 
	char arr2[20] = "xxxxxxxxxxxxx";//xxx~\0
	//能把arr1中的字符串拷贝到arr2中
	strcpy(arr2, arr1);//string copy
	//还将\0拷贝进去
	printf("%s\n",arr2);
	return 0;
}

2）自定义函数

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

函数的组成

ret_type fun_name(para1, * )

{

statement;//语句项

}

ret_type 返回类型

fun_name 函数名

para1 函数参数

#include<stdio.h>
int Getmax(int x,int y)//求两个数较大值
{
	return x > y ? x : y;
}
int main()
{
	int a = 10;
	int b = 0;
	scanf("%d %d", &a, &b);
	int m = Getmax(a, b);
	printf("%d\n", m);
	return 0;
}

3. 函数的参数

3.1 实际参数（实参）：

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

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

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

3.2 形式参数（形参）：

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

形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

//当实参传给形参时，形参是实参的一份拷贝
//对形参的修改不会影响实参
void Swap1(int x, int y)//形参
{
	int temp = 0;
	temp = x;
	x = y;
	y = temp;
}

//void Swap2(int* x, int* y)
//{
//	int temp = 0;
//	temp = *x;
//	*x = *y;
//	*y = temp;
//}
//int main()
//{
//	int a = 0;
//	int b = 0;
//	scanf("%d %d", &a, &b);
//	printf("交换前：a=%d b=%d\n", a, b);
//	Swap2(&a, &b);//实参
//	printf("交换后：a=%d b=%d\n", a, b);
//	return 0;
//}

形参相当于是对实参的一份拷贝，上图pa pb实际拷贝了p1 p2中a b的地址

4. 函数的调用

4.1 传值调用

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

4.2 传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

4.3 练习

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

//打印100-200之间的素数
#include<stdio.h>
#include<math.h>
int 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 = 101; i <= 200; i += 2)
	{
		if (Prime(i) == 1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}

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

//写一个函数判断一年是不是闰年。
// 让函数代码功能足够单一，可以重复利用，尽量不要实现功能还一边打印
//#include<stdio.h>
//int leap_year(int x)
//{
//	return (((x % 4 == 0) && (x % 100 != 0)) || (x % 400 == 0));
//}
//int main()
//{
//	int year = 0;
//	scanf("%d", &year);
//	if (leap_year(year) == 1)
//		printf("%d是闰年\n", year);
//	else
//		printf("%d不是闰年\n", year);
//	return 0;
//}

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

//3. 写一个函数，实现一个整形有序数组的二分查找。
#include<stdio.h>
int binary_search(int arr[], int x,int y)
{
	int left = 0;
	int right = y - 1;
	while (left <= right)
	{
	int mid = left + (right - left) / 2;
	if (arr[mid] < x)
	{
		left = mid + 1;
	}
	else if (arr[mid] > x)
	{
		right = mid - 1;
	}
	else
		return mid;
	}
	return 0;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int m = 0;
	if (m = binary_search(arr, n,sz))
	{
		printf("%d的下标为%d\n", n, m);
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

错误示范——数组传参

//数组在函数中传参时，传递的不是整个数据,
// 而是传递的首元素地址
//这里函数中形参arr接收的实际是一个指针int* arr
//这个指针指向数组的元素首地址
//因此在32位—指针变量占4个字节，64位中—8个字节

//数组在函数中传参时，传递的不是整个数据,
// 而是传递的首元素地址
//这里函数中形参arr接收的实际是一个指针int* arr
//这个指针指向数组的元素首地址
//因此在32位—指针变量占4个字节，64位中—8个字节
#include<stdio.h>
//函数传递的是数组元素首地址，不会创建数组，所以这里传递数组无需指定大小
int binary_search(int arr[], int x)
{
	int sz = sizeof(arr) / sizeof(arr[0]);//这里计算结果为1
	int left = 0;       
	int right = sz - 1;
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] < x)
		{
			left = mid + 1;
		}
		else if (arr[mid] > x)
		{
			right = mid - 1;
		}
		else
			return mid;
	}
	return 0;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int m = 0;
	if (m = binary_search(arr, n))
	{
		printf("%d的下标为%d\n", n, m);
	}
	else
	{
		printf("找不到\n");
	}
	return 0;
}

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

//4. 写一个函数，每调用一次这个函数，就会将num的值增加1。
#include<stdio.h>
void test(int* x)
{
	//*x += 1;正确
	//*x++;//错误的，因为++的优先级高于解引用操作符
	(*x)++;//正确
}
int main()
{
	int num = 0;
	test(&num);
	printf("%d\n",num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	test(&num);
	printf("%d\n", num);
	return 0;
}

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

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

5.1 嵌套调用

//嵌套调用
void new_line()
{
	printf("heheda\n");
}
void three_line()
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		new_line();
	}
}
int main()
{
	three_line();
	return 0;
}

5.2 链式访问

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

5.2.1——strlen函数与printf函数具体讲解

//链式访问
#include<string.h>
//strlen—计算字符长度，不包括/0—头文件string.h—返回值size_t—无符号整形
//int main()
//{
//	int len = strlen("abcdef");
//	printf("len=%d\n", len);
//	return 0;
//}
int main()
{
	//这里就叫链式访问，把strlen的函数返回值
	//放在printf函数里作为参数
	printf("len=%u\n", (unsigned)strlen("abcdef"));
	//%u——打印无符号整数类型
	return 0;
}
/* strlen example */
//#include <stdio.h>
//#include <string.h>
//
//int main()
//{
//	char szInput[256];
//	printf("Enter a sentence: ");
//
//	gets(szInput);
//	printf("The sentence entered is %u characters long.\n", (unsigned)strlen(szInput));
//	return 0;
//}

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	//结果为4321
	//先打印43，printf——返回类型位为打印字符的个数
	//字符“43”打印了两个字符；返回2
	//字符“2”打印了一个字符；返回1
	return 0;
}

6. 函数的声明和定义

//函数的声明和定义
//int Add(int x, int y);//函数的声明
int Add(int, int);//形参的名字可以省略
int main()
{
	int a = 10;
	int b = 20;
	int sum = Add(a, b);
	printf("%d\n", sum);
	return 0;
}
int Add(int x, int y)//函数的定义
{
	return x + y;
}

6.1 函数声明：

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

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

6.2 函数定义及模块源码加密：

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

加密过程

使用他人所提供代码

test.h的内容

放置函数的声明

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



#endif //__TEST_H__

test.c的内容放置

函数的实现

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

7. 函数递归

#include<stdio.h>
//主函数自己调用自己
int main()
{
	//printf("hehe\n");
	main();//错误信息——栈溢出——stack overflow
	return 0;
}

错误信息：栈溢出

每一个函数的调用都会在栈区开辟一份空间

7.1 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。

递归做为一种算法在程序设计语言中广泛应用。

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

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

7.2 递归的两个必要条件

7.2.1 练习1：

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

//接受一个整型值（无符号），按照顺序打印它的每一位。
//例如：输入：1234，输出 1 2 3 4.
#include<stdio.h>
void print(int x)
{
	if (x > 9)
	{
		//x /= 10;
		print(x/10);
	}
	printf("%d ", x%10);
}
int main()
{
	unsigned int input = 0;
	scanf("%u", &input);//1234
	print(input);//可以把input每一位按照顺序打印出来
	//print(1234)
	// print(123)4
	// print(12)3 4
	// print(1)2 3 4
	// 1 2 3 4
	// 
	//打印出1 2 3 4
	//1234%10=4
	//1234/10=123
	//123%10=3
	return 0;
}

7.2.2 练习2：

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

//编写函数，求字符串的长度。(不允许创建临时变量)—函数的递归
#include<stdio.h>
//int Strlen(char* str)
//{
//	int count = 0;//统计字符个数
//	while (*str != '\0')
//	{
//		count++;
//		str++;
//	}
//	return count;
//}
//int main()
//{
//	char ch[] = { "abcdefg" };//abcdef\0
//	printf("%d", Strlen(ch));
//	return 0;
//}

//递归思想
int Strlen(char* str)
{
	if (*str != '\0')
		return (1 + Strlen(str+1));
	else
		return 0;
}
//Strlen("abcdef")
//1+Strlen("bcdef")
//1+1+Strlen("cdef")
//1+1+1+Strlen("def")
//1+1+1+1+Strlen("ef")
//1+1+1+1+1+Strlen("f")
//1+1+1+1+1+1+Strlen("f")
//1+1+1+1+1+1+Strlen('\0')
//1+1+1+1+1+1+0
int main()
{
	char ch[] = { "abcdef" };//abcdef\0
	printf("%d", Strlen(ch));
	return 0;
}

7.3 递归与迭代

循环是一种迭代

7.3.1 练习3：

求n的阶乘。（不考虑溢出）

//求n的阶乘——递归方法——不考虑溢出
#include<stdio.h>
int dgjc(int n)
{
	if (n <= 1)
		return 1;
	else
		return n * dgjc(n - 1);

}
int main()
{
	int input = 0;
	scanf("%d", &input);

	printf("n!=%d\n", dgjc(input));
	return 0;
}

7.3.2 练习4：

求第n个斐波那契数。（不考虑溢出）

//斐波那契数列：1，1，2，3，5，8，13，21，34，55，89...
//求第n个斐波那契数。（不考虑溢出）
#include<stdio.h>

//效率太低——用递归有重复大量的计算
int count = 0;
int fib(int n)
{
	if (n == 3)//统计在整个过程中第三个斐波那契数被计算了多少次
		count++;
	if (n <= 2)
		return 1;
	else
		return fib(n - 1) + fib(n - 2);
}
int main()
{
	int input = 0;
	scanf("%d", &input);
	printf("%d",fib(input));
	return 0;
}

非递归思路

//非递归算法；无需重复大量计算
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 input = 0;
	scanf("%d", &input);
	printf("%d\n",fib(input));
	return 0;
}