函数（一）

1. 函数是什么？

数学中我们常见到函数的概念。但是你了解C语言中的函数吗？
维基百科中对函数的定义：子程序

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

2. C语言中函数的分类

1. 库函数
2. 自定义函数

2.1 库函数：

为什么会有库函数？

1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
   像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。

//
//C语言的编译器提供了一些库函数
//printf
//scanf
//strlen
//
//C语言就是语法
//C语言标准就做了一些工作，比如函数名，功能，参数，返回类型：
// 怎么实现（不管），实现是交给编译器厂商实现的
//scanf - 
//prinf
//strlen
//.....
//编译器-厂商
//VS - 微软
//gcc - gcc官方
//clang - 苹果
//
//没有库函数容易出现问题：
//1. 开发效率低
//2. 标准不一
//3. 容易出bug
//

那怎么学习库函数呢？
这里我们简单的看看：www.cplusplus.com
看得懂英文很重要，建议多练习怎么查怎么看。

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

• IO函数 比如（input、output、getchar、putchar）
• 字符串操作函数（strlen、strcmp等等）
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数
  我们参照文档，学习几个库函数：

strcpy

char * strcpy ( char * destination, const char * source );
//函数名，功能，参数，返回类型

//例子
#include<stdio.h>
#include<string.h>
//库函数的使用一定要包含头文件
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello bit";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

memset

void * memset ( void * ptr, int value, size_t num );
//函数名，功能，参数，返回类型

//例子
#include<stdio.h>
#include<string.h>
int main()
{
	char arr1[] = "hello bit";
	memset(arr1, 'x', 5);
	printf("%s\n", arr1);//xxxxx bit
	return 0;
}

注：
但是库函数必须知道的一个秘密就是：使用库函数，必须包含 #include 对应的头文件。
这里对照文档来学习上面几个库函数，目的是掌握库函数的使用方法。

2.1.1 如何学会使用库函数？

需要全部记住吗？No
需要学会查询工具的使用：

• MSDN(Microsoft Developer Network)
• www.cplusplus.com
• http://en.cppreference.com（英文版）
• http://zh.cppreference.com（中文版）

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

2.2 自定义函数

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

ret_type fun_name(para1, * )
{
 statement;//语句项
}
ret_type 返回类型
fun_name 函数名（自己取，但是不能是关键字，不以数字开头）
para1    函数参数（可以有一个，很多个，也可以没有）
//这里{}这部分叫做函数体

我们举一个例子：

写一个函数可以找出两个整数中的最大值。

//函数的定义
int get_max(int x, int y)
{
	int z = x > y ? x : y;//这里使用条件操作符判断大小
	return z;
}
#include<stdio.h>
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);//输入
	//函数的使用-场景
	int m = get_max(a, b);//函数的调用
	printf("%d\n", m);
	return 0;
}

再举个例子：

写一个函数可以交换两个整形变量的内容。

错误版本

//函数的定义
void Swap(int x, int y)
{
	int t = 0;
	t = x;
	x = y;
	y = t;
	return x,y;
}
#include<stdio.h>
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\n", a,b);
	return 0;
}
//打印结果：
//10 20
//交换前a = 10 b = 20
//交换后a = 10 b = 20
//当函数调用的时候
//实参(这里的a,b)传给形参(这里的x,y)时，形参将是实参的一份临时拷贝
//所以对形参的修改是不影响实参的

可以发现，打印结果并没有实现两个数的交换，是因为这里a的地址和x的地址不一样，b的地址和y的地址也不一样，只是把数值传过去了，并没有把地址传过去，地址不一样，内存空间就不一样，这里只是x,y被交换了，a,b没有影响。

正确版本：

//正确版本
void Swap(int* px, int* py)
//*说明了px是指针，int表示px指向的a是整型
//px得到a的地址 ，就能找到a
{
		int t = 0;
		t = *px;
		*px = *py;
		*py = t;
}
#include<stdio.h>
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\n", a, b);
	return 0;
}
//利用指针让Swap函数和main函数之间的数据建立了联系

随便输两个数字，如图，可以正确交换

2.3函数的参数

2.3.1实际参数（实参）：

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

2.3.2形式参数（形参）：

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

比如：

//求两个数较大值
#include <stdio.h>
int get_max(int x,int y)//这里x,y是形参
{
	return(x > y ? x : y);
}
int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int m = get_max(a, b);//这里的a,b是实参
	//int m = get_max(a, get_max(3,4));
	//这里的a,get_max(3,4)是实参,也就是a和4比较
	printf("%d\n", m);
	return 0;
}

2.4函数的调用：

2.4.1传值调用

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

2.4.2传址调用

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

参照2.2当中的例子：写一个函数可以交换两个整形变量的内容，最后发现形参实例化之后其实相当于实参的一份临时拷贝。
如果只是传值调用，形参是实参的临时拷贝，内容一样，但是形参和实参的地址不会一样，所以形参数值的交换并不影响实参，具体参考例子“错误写法：写一个函数可以交换两个整形变量的内容”；
传址调用，实参和形参的地址是一样的（可以通过普通调试Fn +F10和进入函数调试Fn +F11查看地址是否一样），可以通过形参找到实参。

用传值调用还是传址调用看情况，能完成任务就行。

2.4.3 练习

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

//1. 写一个函数可以判断一个数是不是素数
//打印100~200之间的素数
//是素数返回1
//不是素数返回0
#include <stdio.h>
#include<math.h>
int is_primer(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;
	int count = 0;
	for (i = 100; i <= 200; i++)
	{
		if (is_primer(i) == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\ncount = %d\n", count);
	return 0;
}

关于啥时候用return 啥时候不用要看情况，比如下面这个例子：写一个函数来打印数组arr

#include <stdio.h>
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	print(arr, 10);
	return 0;
}

//不用函数挨个打印，像这样
#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d %d %d %d %d %d %d %d %d %d",arr[0],arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8], arr[9]);
	return 0;
}

小知识拓展–》关于返回值

//函数，如果不写返回值，函数默认会返回一个值
//有些编译器上返回的是：最后一条指令产品的结果
#include<stdio.h>
int test()
{
	int a = 10;
	int b = 20;
	int c1 = a + b;
	int c = a - b;
}

int main()
{
	printf("%d\n", test());
	return 0;
}

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

//打印1000~2000
#include <stdio.h>
int is_leapyear(int x)
{
	if (((x % 4 == 0) && (x % 100 != 0)) || (x % 400 == 0))
		return 1;
	else
		return  0;
}
int main()
{
	int i = 0;
	int count = 0;
	for (i = 1000; i <= 2000; i++)
	{
		if (is_leapyear(i) == 1)
		{
			count++;
			printf("%d ", i);
		}
	}
	printf("\ncount = %d\n", count);
	return 0;
}

//函数这部分像这样写也可以
int is_leapyear(int x)
{
	return (((x % 4 == 0) && (x % 100 != 0)) || (x % 400 == 0));
}

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

//写一个函数，实现一个整形有序数组的二分查找
#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;
		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] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int k = 17;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//用整个数组的大小除以每个数组（第一个数组）的大小就等于数组的个数
	//strlen求的是字符串长度,sizeof求的是数组的长度
	int ret = binary_search(arr,k,sz);
	if (-1 == ret)
		printf("找不到\n");
	else
		printf("找到了，下标是：%d\n", ret);
	return 0;
}
//数组传递值的时候不会把整个数组都传过去
//数组传参，传递的是数组首元素的地址，在函数外面计算数组个数
//所以这里的sz个数的计算只能在函数外面，也就是在main函数里面计算

如果查找的k是17，那么不存在：

如果查找的k是6，那么存在：

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

//写一个函数，每调用一次这个函数，就会将 num 的值增加1。
#include <stdio.h>
void add(int* x)
{
	*x = *x + 1;
}
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;
}

这里调用了3次，所以效果如下图所示：

第二种写法，采用传值调用：

#include <stdio.h>
int add(int x)
{
	return x + 1;
}
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;
}

注意：

//为什么不能写成*x++而写成*x = *x + 1呢？
//因为++的优先级高于*，所以++会先作用于x，而不是*x，
//我们要改变的是*x的内容，而不是x的内容

那如果非要写成++的形式呢？

#include <stdio.h>
void add(int *x)
{
	(*x)++;
}
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;
}
//因为()的优先级高于++，先执行()里面的再++

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

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

2.5.1 嵌套调用

#include <stdio.h>
void new_line()
{
	printf("hehe\n");
}
void three_line()
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		new_line();
	}
}
int main()
{
	three_line();
	return 0;
}

函数可以嵌套调用，但是不能嵌套定义。

2.5.2 链式访问

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

示例1：一般计算字符串个数像这样写

#include <stdio.h>
int main()
{
	int c = strlen("abcdef");
	printf("%d\n", c);
	return 0;
}

我们用链式访问：把strlen函数的返回值作为printf函数的参数

#include <stdio.h>
int main()
{
	strlen("abcdef");
	printf("%d\n", strlen("abcdef"));
	return 0;
}

打印结果是一样的：

示例2：

#include <stdio.h>
int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	//结果是啥？
	//注：printf函数的返回值是打印在屏幕上字符的个数（可以通过c++官网查看函数的使用）
	//printf("%d", printf("%d", 2));
	//printf("%d", 1);
	//4321
	return 0;
}

为什么打印结果是4321？
printf(“%d”, 43)的返回值是2，因为43是两个字符，所以 printf(“%d”, printf(“%d”, 43))链式访问后就相当于printf(“%d”, printf(“%d”, 2))。由于printf(“%d”, 2)的返回值是1，因为只有2一个字符，所以 printf(“%d”, printf(“%d”, 2)) 链式访问后就相当于 printf(“%d”, 1) 。 所以最后结果是4321。

2.6函数的声明和定义

2.6.1函数声明：

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

如果函数的定义放在了调用的步骤之后，要提前声明。

#include <stdio.h>
int add(int, int);//声明函数的类型、名字、参数类型
//只要放在调用函数之前就行
//第二种声明写法：把参数名称加上也行，不影响
//int add(int a, int b)
int main()
{
	int a = 1;
	int b = 2;
	printf("%d\n", add(a, b));
	return 0;
}
int add(a, b)
{
	return a + b;
}

2.6.2分模块调用

这种写法不常见，更多的是分模块进行，比如下面这个例子：
把函数的定义放在.c文件"add.c"里面，把函数的声明放在头文件"add.h"里面，.c文件"test.c"用来包含自定义头文件和调用函数。需要注意的是，自定义的头文件用引号括起来，系统头文件用尖括号括起来，从而区分头文件到底是自定义的还是系统的。

• 这是"test.c"文件里面的内容

//分模块进行声明
#include "add.h"
#include <stdio.h>
int main()
{
	int x = 0;
	int y = 0;
	scanf("%d %d", &x, &y);
	printf("%d\n", add(x, y));
	return 0;
}

• 这是"add.c"文件里面的内容

//函数的定义
int add(int a, int b)
{
	return a + b;
}

• 这是"add.h"文件里面的内容

//头文件中放：函数的声明，类型的定义，头文件的包含
int add(int a, int b);

最后运行，随便输入两个数30和40，效果如下图所示：

2.6.3拓展（关于VS，gitee、静态库）

1.关于对VS的理解

/*
- VS2019 是编译器吗？
不是，其实是集成开发环境，简称IDE
集成了这些功能：编辑器，编译器，链接器，调试器
*/

2.提交gitee时日志修改不了

SVN这种叫做版本管理工具，上一个版本的提交日志，文字内容是修改不了，所以提交代码commit的时候添加日志也就是汉字的那部分内容时要注意，不要写错字，不然提交后修改不了。

3.静态库

假如李四认为张三写的这个（假装这个有加法功能的工程是游戏）游戏很好，想要借鉴一下，但是张三不想让他看见源代码，怎么办呢？
这里的add工程（张三的工程）一共包含两个文件，"add.c"的内容是函数的定义，头文件"add.h"的内容是函数的声明。

这里李四的工程，也就是test_5_13，一共有一个.c文件"test.c"，用来包含自定义头文件和调用函数，也就是这两句代码。（不过后面为了实现有关功能，会添加张三的头文件"add.h"，所以那时候一共才有两个文件）

#include "add.h"
printf("%d\n", add(x, y));

这是前情提要，李四只会调用，不会定义某些功能，所以向张三买代码，但是张三，不想让他看源代码，操作如下所示：
1.首先鼠标右击工程文件名"add"，点击"属性"

2.如图所示，把配置类型改成.lib文件

3.点击"应用 "

运行一下，发现运行不了，但是生成了一个"add.lib"文件


然后返回到后台debug那看看，发现有.lib文件，这个是游戏引擎所对应的静态库文件，这个静态库被李四买走后就可以用了。

4.把这个add.lib文件复制到之前的工程文件里面，发现打开是乱码：
注意，像这样放在没有.c文件的位置是错误的，因为后面运行不了，打不开.lib文件，放到这个路径查看没有问题，但是要运行一定要像第二张那样放到有.c文件的目录下。


（我这里的红色感叹号不用管，因为本地仓库代码的内容被改变，没有重新提交到gitee的那边仓库，所以是个更新内容的提示）

5.这个add.lib里面是二进制信息，所以看不懂，并不是李四被骗了，这里面包含了很多有用的信息。这个时候把"add.h"文件也买过来，打开，运行，如图：

6.难道李四被骗了？add工程里面的.lib文件放到了自己工程目录下面，头文件也添加进来了，那为什么还是用不了呢？
那是因为他没有加载静态库。
添加这一行代码就可以：

#pragma comment(lib,"add.lib")

#pragma comment(lib,“文件名.lib”)这里的lib文件是add.lib，所以像上面那样写。

像这样就可以成功运行了！
7.随便输入两个数，如图：

张三的目的达到了，李四虽然可以成功运行，但是他压根不知道"add.lib"文件里面有什么，也不知道"add.c"里面写的什么东西，只知道"add.h"里面有哪些函数，不过不知道怎么实现的。

所以未来如果你不想把自己.c文件里面重要的功能暴露出去，就只给对方头文件就行，前提是你自己写代码是分模块进行的，而不是一股脑全写在.c文件里，这样就不能对代码进行保护，也就是不能把模块编译成静态库。