目录

一、函数是什么？

数学中我们常见到函数的概念，但是你了解C语言中的函数嘛？

二、C语言中函数的分类

1.库函数

为什么会有库函数？

2.自定义函数

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

三、函数的参数 

1.实际参数（实参）

2.形式参数（形参）

四、函数的调用

1.传值调用

2.传址调用

3.练习

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

1.嵌套调用

 2.链式访问

 六、函数的声明和定义

1.函数声明

2.函数定义

七、函数递归

 1.什么是递归

2.递归的两个必要条件

下期预告

一、函数是什么？

数学中我们常见到函数的概念，但是你了解C语言中的函数嘛？

维基百科中对函数的定义：子函数

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

二、C语言中函数的分类

库函数和自定义函数。

1.库函数

为什么会有库函数？

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

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

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

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

我这里提供几个网站：www.cplusplus.comhttp://www.cplusplus.com/reference/

 

        英文版  ：

cppreference.comhttps://en.cppreference.com/w/        

       中文版：

cppreference.comhttps://zh.cppreference.com/w/

 

       以上的这些网站里面的文档可以查阅你想要是现实的一些功能可以用哪些库函数实现，还可以查阅你所用的库函数的用法以及需要什么样的头文件。

学会看文档很重要，因为我们不一定能全部记得住那么库函数和它的使用方法，但是我们得学会自己查阅文档。还有我们要看得懂英文文档，英文很多牛的文献都是用英文写的，所以英语很重要！

虽然说这里面也有中文的文档，但是还是希望你可以看英文的哈，在学C语言的同时也可以学一下英语，一举两得哈！

注：库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。

2.自定义函数

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

所有更加重要的是自定义函数。

自定义函数和库函数一样，有函数名，返回值类型和函数参数。

但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。

函数的组成：

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

 例如：写一个函数可以找出两个整数中的最小值。

#include
int get_min(int x, int y)//定义的函数名为get_max,返回的值为整型，传入的两个数为整型，分别为x，y
{
	int z = 0;
	z = (x < y ? x : y);//如果x 
三、函数的参数  
函数的参数分别有实际参数和形式参数。
 
1.实际参数（实参） 
真实传给函数的参数，叫实参。
 
实参可以是：常量、变量、表达式、函数等。
 
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形 参。
 
2.形式参数（形参） 
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内 存单 元），所以叫形式参数。
 
形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
 
四、函数的调用 
1.传值调用 
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
 
2.传址调用 
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
 
这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操 作函数外部的变量。
 
3.练习 
1.写一个函数打印1~100之间的所有素数。
 
 
 
首先，我们得知道什么是素数。素数也叫质数，就是说除了1和它本身以外，无法被其他整数整除的数就叫素数。
 
 
#include
//
//int is_prime(int n)
//{
//	//拿2 ~ n-1的数字试除
//	int j = 0;
// //是素数返回1，不是素数返回0
//	for (j = 2; j < n; j++)
//	{
//		if (n % j == 0)
//		{
//			return 0;
//		}
//	}
//	return 1;//是素数
//}

//优化
#include//sqrt()库函数所需要的头文件
int is_prime(int n)
{
	//拿2~ n的开平方根的数字试除
	int j = 0;
//是素数返回1，不是素数返回0
	for (j = 2; j <= sqrt(n); j++)//sqrt(n)对n开平方根，是库函数
	{
		if (n % j == 0)
		{
			return 0;
		}
	}
	return 1;//是素数
}
int main()
{
	int i = 0;
	for (i = 1; i <= 100; i++)
	{
		//判断i是否为素数 - 如果是素数就打印i
		if (is_prime(i) == 1)
		{
			printf("%d ", i);
		}
	}
	return 0;
}
 
2. 写一个函数算一下1000~2000年中有多少个闰年并把它们打印出来。
 
 
 
首先，我们得知道什么样的年份才是闰年，它有什么特性？所谓的闰年就是说，它能被4整除并且不能被100整除，或者能被400整除的年份就是闰年。
 
 
 
#include
int is_leep_year(int n)
{
      //是闰年返回1，不是闰年返回0
	if ((n % 4 == 0 && n % 100 != 0) || n % 400 == 0)
		return 1;
	else
		return 0;
	//也可以
	//return ((n % 4 == 0 && n % 100 != 0) || n % 400 == 0);
}
int main()
{
	int count = 0;
	int y = 0;
	for (y = 1000; y <= 2000; y++)
	{
		//判断是不是闰年
		if (is_leep_year(y))
		{
			printf("%d ", y);
			count++;//累计闰年的个数，打印一个闰年后，count就进行加1一次
		}
	}
	printf("n%dn", count);

	return 0;
}
 
3.写一个函数，实现一个整型有序数组的二分查找，如果找到就返回下标，找不到返回-1。
 
#include
int binary_search(int arr[], int k,int size)//形参和实参的名字可以相同
{
	int left = 0;
	int right = 0;
	int mid = 0;
	//int size = (sizeof(arr) / sizeof(arr[0]));//把这句写在这里会出错，已经传过来的是数组首元素的地址，计算不了数组元素的个数
	right = size - 1;
    while(left <= right)
	{
		
		mid = (left + right) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if(arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;//就是找不到了
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 7;//要找的数字

    //因为是整型数组，所以一个元素占4个字节
//算的是整个数组的大小4*10，第一个元素的大小 4
	int size = (sizeof(arr) / sizeof(arr[0]));//可以算数组中元素的个数
              //         40/4=10 
	//数组arr传给binary_search函数的时候，其实传递的是arr数组首元素的地址
	int ret = binary_search(arr, k,size);//调用二分查找的函数
	if (-1 == ret)
	{
		printf("找不到n");
	}
	else
	{
		printf("找到了,下标是%dn", ret);
	}

	return 0;
}
 
 3.写一个函数，每次调用一次这个函数，就会将num的值增加1。
 
#include
void add(int *p)  //函数的返回类型为void，就是无返回
{
	*p = *p + 1;
}
int main()
{
	int num = 0;
	add(&num);
	printf("%dn", num);
	add(&num);
	printf("%dn", num);
	return 0;
}
 
 五、函数的嵌套调用和链式访问 
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
 
1.嵌套调用 
#include 
void new_line()
{
    printf("hehen");
}
void three_line()
{
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        new_line();
    }
}
int main()
{
    three_line();
    return 0;
}
 
 
 
注：函数可以嵌套调用，但是不能嵌套定义 。
 
 
 2.链式访问 
把一个函数的返回值作为另外一个函数的参数。
 
#include 
#include //strlen()函数所需要的头文件
int main()
{
    char arr[20] = "hello";
    //strlen()函数是计算字符串的长度的，字符串最后都会隐藏着一个'',遇到''就停止计算
    //strcat()函数是拼接字符串的
    int ret = strlen(strcat(arr, "hhh"));//这里就是先把两个字符串拼接起来，再返回给strlen()函数计算它们的长度
    printf("%dn", ret);
    return 0;
}
 
 六、函数的声明和定义 
1.函数声明 
①告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
 
② 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
 
③ 函数的声明一般要放在头文件中的。
 
2.函数定义 
函数的定义是指函数的具体实现，交待函数的功能实现。
 
 
 
 
 
①就比如我在工程文件的头文件里面创建了一个game.h文件，在源文件里面创建了一个test.c和game.c文件。
 
 
②game.h是专门用来放函数的声明和写头文件的，就是把源文件里面的库函数所需要用到的头文件，全部写到该文件里。
 
 
③test.c是专门用来写程序的逻辑结构的，game.c是专门用来写各种自定义函数的实现的。
 
 
④我们只要在test.c和game.c里面的最上方加上一个#include"game.h"头文件，game.h里面的函数声明和头文件就可以供game.c和test.c所用。
 
 
⑤这种分文件的书写形式，可以使我们的逻辑更加清晰，可以避免代码冗余。
 
 
七、函数递归 
 1.什么是递归 
程序调用自身的编程技巧称为递归（recursion）。
 
递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。
 
递归的主要思考方式在于：把大事化小。
 
2.递归的两个必要条件 
①存在限制条件，当满足这个限制条件的时候，递归便不再继续。
 
②每次递归调用之后越来越接近这个限制条件
 
例如，在不创建临时变量的前提下，求字符串的长度，我们就可以用递归的方法。
 
#include

//非递归法，创建临时变量的
int my_strlen1(char* s)
{
	int count = 0;
	while (*s != '')
	{
		count++;//临时变量
		s++;//如果是整型指针的，要加4，因为占四个字节
	}
	return count;
}

//递归的方法
int my_strlen(char* s)
{
	if (*s == '')//因为字符串的最后有'',可以用这个作为判断字符串结束的标志
		return 0;
	else
		return 1 + my_strlen(s + 1);
}
int main()
{
	//求字符串的长度
	char arr[] = "abc";
	//arr是数组名，数组名是数组首元素的地址
	int len = my_strlen(arr);//char *

	printf("%dn", len);
	return 0;
}
 

提示：①许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
 
           ②但是这些问题的迭代实现往往比递归实现的效率更高，虽然代码的可读性稍微差一些。
 
           ③当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来               的运行时开销。
 
下期预告 
分享一下自己对函数递归的两个经典题目的理解
 
①汉诺塔问题
 
②青蛙跳台阶问题
 
 
以上只是个人的一些理解，要是哪里写得不好或者有错误，欢迎各位大佬在评论区给我留言指出我的错误。