初级C语言之【函数】

🦖作者：学写代码的恐龙
🦖博客主页：学写代码的恐龙博客主页
🦖专栏：【初级c语言】
🦖语录：❀未来的你，一定会感谢现在努力奋斗的自己❀

一：函数是什么？

下面是维基百科对函数的定义：

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

二：函数的分类

• 库函数
• 自定义函数

2.1：库函数

2.1.1：为什么会有库函数？

1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。

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

2.1.2：如何学习库函数？

下面给大家提供两个网站，可以通过这两个网站来查找学习一些库函数

https://cplusplus.com/
https://zh.cppreference.com

C语言常用的库函数都有：

• IO函数 （输入、输出函数：scanf、printf）
• 字符串操作函数
• 字符操作函数
• 内存操作函数
• 时间/日期函数
• 数学函数
• 其他库函数

2.1.2.1：strcpy函数

通过上面的网站我们可以查到strcpy这个函数的功能，以及它的参数和返回值的一些信息，掌握了这些信息以后我们就可以利用这个函数来帮助我们完成一些工作。通过上面图片中的介绍，我们可以知道这其实是一个字符串拷贝函数，这函数有两个字符型的指针变量作为参数，它的返回值也是一个字符型的指针变量并且就是第一个参数destination

下面通过实例来为大家展示一下，我们利用strcpy这个函数把arr2数组里面存储的字符串拷贝到arr1里面去。（注意使用strcpy需要包含这个头文件）

#include 
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello word";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9

实际上arr2数组在"hello word"后面还存储了一个’\0’，再用strcpy拷贝的时候会把’\0’也拷贝过去。


当然strcpy函数有返回值，我们也可以定义一个字符型的指针变量来接受这个返回值。我们上面的代码没有定义一个变量来接收这个返回值主要是因为，通过对strcpy函数的介绍我们得知它的返回值其实就是第一个参数arr1，这里arr1就是数组的首地址，而打印一个字符串我们只需要知道第一个字符的地址就可以，程序会从第一个字符开始打印一直到’\0’才停下来。因此我们就可以直接利用arr1把拷贝后数组中的内容打印出来。

#include 
int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello word";
	char* cet=strcpy(arr1, arr2);//用cet这个变量来接收strycpy函数的返回值
	printf("%s\n", cet);
	return 0;
}
1
2
3
4
5
6
7
8
9

2.1.2.2：memset函数

这个函数的作用就是把ptr指向的空间，其后面的num个字节存储的数据设置成value这个值

#include 
int main()
{
	char arr1[20] = "hello word";
	printf("%s\n", arr1);
	memset(arr1, 'w', 5);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9

通过程序的运行结果可以看出，我们利用memset函数成功的把"hello word"的前5个字符全部换成了’w’。

2.2:自定义函数

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

2.2.1：函数的组成

ret_type fun_name(para1, * )
{
 statement;//语句项
}
1
2
3
4

其中：

• ret_type是返回类型
• fun_name是函数名
• para1是参数,*表示其他参数（注意：参数也有类型）

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

int getmax(int x, int y)
{
	if (x > y)
	{
		return x;
	}
	else
	{
		return y;
	}
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int c = getmax(a, b);
	printf("%d\n", c);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

其中int就是函数的返回值类型，getmax就是函数名，x和y就是函数的两个参数，大括号括起来的就是函数体。

具体的工作原理：

当程序走到函数调用语句getmax(a,b)的时候，会把a传给x，b传给y。如果我们输入的a，b分别是3和5的话，那此时x=3，y=5，所以x是小于y的，程序执行return y；就把y的值返回到主函数里，我们定义了一个整型变量c接收这个返回值。此时c就是5.

通过监视窗口我们也能看出x存的就是a的值，y存的就是b的值。

可以对getmax这个函数的函数体进行简化，简化后的代码如下：

int getmax(int x, int y)
{
	return (x > y ? x : y);
}
1
2
3
4

这里主要是用到了条件操作符。

2.2.3：什么时候用void？

如果这个函数不需要返回值，我们就在函数名前加上void表示这个函数没有返回值，常见的如果这个函数里只执行了打印操作，那么一般情况下这个函数是不需要返回值的。注意啦！！！如果函数不需要返回值，我们一定要写上void，因为：函数的返回类型不写的时候，默认返回的是int类型
还有一种情况，当这个函数不需要参数的时候我们会在函数名后面的括号里写上void。
具体如下：

void text(void)
{
	printf("hehe\n");
}
1
2
3
4

这个text函数仅仅执行了一个打印hehe的操作，它没有返回值，我们就在text前面写上void，同时打印也不需要参数，我们就在text后面的括号里写上void。函数调用结果如下图：

如果当我们把text函数前面的void去掉时：

可以看出此时程序默认text函数的类型是int型，这时疑问就来了，既然函数的类型是int型，说明调用完这个函数后会返回一个整型值，但是我们这个函数里没有return语句呀，那他返回的到底是什么呢？为了知道此时text函数的返回值，我们在主函数里用一个整型变量ret来接收一下这个返回值，并把它打印出来，这样就可以知道它的返回值了。

不难看出，它的返回值是5。为什么呢？这主要取决于编译器，大多数编译器，默认的函数返回值，是该函数里最后一条语句的执行结果，这就说明5是printf函数执完的结果。而prinf函数的执行结果就是他打印出来的字符个数。"hehe\n"一共有5个字符，printf函数的执行结果就是5。（这里大家可以去printf函数详情介绍里进行深入理解。

总结：在写代码的时候不能模棱两可，函数的返回值是什么就写什么，如果没有返回值就写void

2.2.4：写一个函数交换两个整型变量的内容

void Swp(int x,int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	//输入
	scanf("%d %d", &a, &b);

	printf("交换前：a=%d b=%d\n", a, b);
	//交换
	Swp(a, b);

	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

大家看看这段代码，是不是觉得写的没什么毛病，调用Swp这个函数把a和b的值进行交换。但结果真的像我们想的那样嘛？

通过代码的运行结果看出虽然我们调用了Swp函数对a和b的值进行交换，但实际的结果是：调用完Swp函数之后a和b的值并没有被交换。下面我们通过监视来看看问题出现在哪里？

当程序走到Swp(a,b)的时候，把a传给了x，b传给了y，此时a=x=3，b=y=5，通过监视窗口可以看出Swp函数经过一些列的操作后确实交换了x和y的值，但是a和b的值却始终没被交换，原因在于：通过监视窗口我们可以看出，虽然a把它的值传给了x，但是a和x的地址并不相同，同样b和y的地址也不相同。还记得地址可以干什么嘛？我们可以通过地址找到这个地址里“住的”数据。这里的a、b、x、y四个变量的地址各不相同，所以他们就像酒店里4个不同的房间都有着各自的房间号（房间号就是地址），假设有两对双胞胎，分别记作双胞胎1和双胞胎2，原本双胞胎1的哥哥住在a房间，双胞胎2的哥哥住在b房间，双胞胎1的弟弟住在x房间，双胞胎2的弟弟住在y房间。此时我们让双胞胎1的弟弟和双胞胎2的弟弟交换房间，交换后，双胞胎2的弟弟住在x房间，双胞胎1的弟弟住在y房间，他俩的交换会对他们的哥哥造成影响嘛？显然并不会影响他们的哥哥，双胞胎1的哥哥还是住在a房间，双胞胎2的哥哥还是住在b房间，他俩没有发生任何变化。我们代码里的a和x就相当于这里的双胞胎1（他俩的值都是3），b和y就相当于双胞胎2（他俩的值都是5），虽然a和x一模一样，b和y一模一样，但是我们交换x和y，并不会对a和b产生任何影响。我这样解释不知道大家有没有听懂。下面再画图为大家解释一下：

起初我们定义a和b的时候，就像系统申请了两块内存，当我们输入3和5的时候，就把3存到a里面，把5存到b里面，在调用Swp函数的时候，把a传给x，此时x是重新开辟了一块内存来存储3，同理，把b传给y，y也是重新开辟了一块空间，我们让x和y的值进行交换，并没有对a和b产生任何影响。

官方一点的解释就是，a和b叫做实参，x和y叫做形参，当函数调用的时候，实参传递给形参，这时形参是实参的一份临时拷贝，对形参的修改不影响实参。

如何解决这个问题呢？

还是刚才那个双胞胎的例子，如果我们真的想让双胞胎1的哥哥和双胞胎2的哥哥交换房间，那我们就直接去找到他俩的房间号（地址）让他俩交换就可以了。程序也是这样，我们直接把a和b的地址告诉给Swp函数，让Swp函数通过地址去找到a和b，完成他俩的交换任务。

就像上面代码所展示的：起初定义a=10，然后把a的地址存放在pa里面，我们可以用解引用操作*pa去改变a的值。
所以我们可以把代码修改如下：

void Swp(int* pa,int* pb)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	//输入
	scanf("%d %d", &a, &b);

	printf("交换前：a=%d b=%d\n", a, b);
	//交换
	Swp(&a, &b);

	printf("交换后：a=%d b=%d\n", a, b);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

让pa和pb分别存放a和b的地址，因为存放的是地址，所以这里的参数pa和pb都必须是指针变量。然后我们通过解引用操作 *pa 和 *pb就可以交换a和b的值了。

此时我们已经成功地交换了a和b的值。

总结一下：求两个数的较大值的时候不传地址是因为，我们只需要知道a和b谁更大，把其中大的数字返回来，并没有让a或者b的值发生任何改变，而交换两个数的时候，我们希望改变a和b的值，所以就传了地址过去。

三：函数的参数

3.1：实际参数（实参）：

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

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

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

实参变量：上面求两个数的较大值中的a和b就是实参变量，a和b的值是我们从电脑上输入进去的。

int c = getmax(a, b);
1

实参常量：当然我们也可以不从电脑上输入两个数来判断大小，我们可以直接让getmax求两个常量的较大值，就像下面这样，这个结果和我们从键盘上输入3和5分别存到a和b里，然后求a和b的较大值的结果是一样的。

int c = getmax(3, 5);
1

实参表达式：我们也可以把5写成3+2，这里的3+2就是一个表达式，他其实就是求3和5的较大值。

int c = getmax(3, 3+2);
1

实参函数：下面的getmax（1，7）就是一个函数，它的意思是，先求1和7的较大值，函数返回值是7，再求7和5的较大值。当然这里的getmax（1，7）还可以是其他的函数，但这个函数必须得有一个整型的返回值，因为这里要比较两个整型数字的大小。

int c = getmax(getmax(1,7), 5);
1

3.2：形式参数（形参）：

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

这里的 *pa 和 *pb都叫做形参

这里的x和y也叫做形式参数。

四：函数的调用：

4.1：传值调用

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

4.2：传址调用

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

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

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

5.1：通过传地址来实现

void Add(int* p)
{
	*p = *p + 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

注意这里不能写成*p++;因为这里的 “++” 优先级高于 ’ * '，所以会先执行p++，因为这里是p是int型的指针变量，所以p++的结果是让p指针向后移动4个字节，指向其他的整型变量。而我们这里是希望num这个变量的值+1.因此我们可以把它写成(*p)++;这样就可以达到我们的目的了。

5.2：通过返回值来实现

int Add(int num)
{
	return num + 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

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

6.1：函数的嵌套调用

#include 

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这段代码在主函数里调用了three_line函数，然后在three_line函数里又调用了new_line函数。在three_line函数里的for循环一共执行了三次，每执行一次就会调用一次new_line函数，而一次new_line函数会打印出"hehe\n"，因此three_line函数会打印出三个"hehe\n"。而three_line想要运行起来，就要把它放在main函数里。这就叫函数的嵌套调用。

注意：函数可以嵌套调用，但是不能嵌套定义。嵌套定义就是在一个函数内部重新定义一个函数，这样是不可以的。

6.2：链式访问

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

int main()
{
	int ret = strlen("abcdef");
	printf("%d\n", ret);
	return 0;
}

1
2
3
4
5
6
7

我们用strlen来求一个字符串"abcdef"的长度，把测得的结果存放在ret里，然后我们通过ret打印出字符串的长的。当我们知道了链式访问以后，就可以直接用strlen(“abcdef”)去替代printf函数里的ret。如下免得代码所示：

int main()
{
	//int ret = strlen("abcdef");
	printf("%d\n", strlen("abcdef"));
	return 0;
}

1
2
3
4
5
6
7

典型示例：
大家看下下面这段代码，猜猜它的运行结果是什么

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	return 0;
}

//运行结果是：4321
1
2
3
4
5
6
7

当程序走到第三行的时候先检测到第一个printf，准备执行它的时候，发现它的参数是printf(“%d”, printf(“%d”, 43))，也就是说第一个printf要打印这个式子的值。那这个式子的值是多少呢？我们可以看出这其实是一个printf函数，它的返回值是打印出的字符的个数。第一个printf就是要把printf(“%d”, printf(“%d”, 43))的返回值打印出来。那这第二个printf到底打印了多少个字符呢，此时我们就要进入第二个printf函数里面去一探究竟了，当进到第二个printf函数里面的时候，我们发现它的参数是printf(“%d”, 43)，也就是说第二个printf函数要把printf(“%d”, 43)的返回值打印出来，此时程序就要先执行printf(“%d”, 43)，看看他到底打印出了几个字符，所以运行结果的前两位是43，打印出来后程序得知printf(“%d”, 43)只打印了43这两个字符，那printf(“%d”, 43)的返回值就是2了，代码就等价成这样：printf(“%d”, printf(“%d”,2));，这下是不是很清楚，第二个printf其实就是打印2，只有第二个printf执行了，第一个printf才能知道printf(“%d”,2)的值是多少，由于第二个printf只打印了’2’这一个字符，所以printf(“%d”,2)的返回值是1，此时代码就变成了这样：printf(“%d”,1);最后，在屏幕上打印出’1’。综上所述，程序的运行结果就是：4321。

七：函数的声明和定义

7.1：函数的声明：

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

7.2：函数的定义：

函数的定义是

大家看下面这段代码，我们在定义Add函数之前就调用了它（int ret = Add(a, b);），此时运行程序会发生什么结果呢？

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//求和
	int ret = Add(a, b);
	printf("%d", ret);
	return 0;
}

int Add(int x, int y)
{
	return x + y;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以看出程序报了一个警告，说Add未定义。报警告的原因是：代码在编译的时候，会从前往后进行扫描，当扫描到第7行的时候，发现调用了Add函数，但是从扫描开始到现在没有发现Add函数的定义，所以程序就会报警告，提示我们Add函数没有定义。所以，对于一个函数，当我们先调用后定义的时候程序就会报警告。

如何解除这个警报呢？我们先找到产生警报的原因，然后对症下药。通过上面的分析我们可以得知：是由于在编译扫描到Add函数调用语句之前，并没发现任何关于Add的信息，这导致编译器并不知道Add是什么，所以在扫描到int ret = Add(a, b)时就报警告。因此，我们可以在代码的最前面加上一条声明语句，告诉编译器，Add其实是一个函数。它的返回值类型是int型，同时他还有两个int型的参数。这样当编译器扫描到int ret = Add(a, b);的时候就知道“哦，原来Add是一个函数”，此时就不会报警告了。

//Add函数的声明
int Add(int x,int y);

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	//求和
	int ret = Add(a, b);
	printf("%d", ret);
	return 0;
}

//Add函数的定义
int Add(int x, int y)
{
	return x + y;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

可以看出，加上函数的声明以后编译就不会再报警告了。

总结：一个函数在调用之前，一定要先声明或者定义，其实定义就是一种特殊的声明，假如函数的定义在函数调用的前面，此时就无需进行函数声明。而如果函数的定义在函数调用的后面就需要在函数调用之前，对函数进行声明。声明的时候可以不用写变量，这需要写出变量的类型，比如这样：

int Add(int , int );//声明可以这样写，编译器只需要知道函数的返回值类型，以及参数的个数和参数的类型。至于形式参数的名字在函数声明的时候我们可以不写
1

但函数的声明和定义其实并不是这样用的，真正的声明和定义是下面这样：

还是以Add函数为例，我们会重新创建一个add.h的头文件用来放Add函数的声明，创建一个add.c的源文件放Add函数的定义（函数的实现）。当我们要在text.c中调用Add函数的时候只需要包含add这个头文件即可。（注意是用双引号）

其中add.h和add.c叫做加法模块，text.c叫做测试模块

拆成几个文件的好处有以下几点：
1、模块化开发
2、代码的隐藏

此时我们的程序也能正常运行。

7.3：补充：对变量的声明和定义

对于一个变量，如果我们在使用这个变量之前，没有对他进行任何的声明或者定义，在编译的时候程序会直接报错。像下面这样：在打印val之前我们没有对val进行任何的声明或者定义，而是在main函数的后面定义了全局变量val=2022。

此时我们只要在打印val之前对其进行声明，编译就不会报错了。

但是！！！如果在声明的时候对val赋了初值，编译的时候也会报错，像下面这样：程序报错说val重定义。

还有一种情况就是：对val声明的时候没有对其赋初值，并且后面没有对val进行定义。像下面这样，整段代码只对val进行了声明，告诉编译器val是一个整型变量，但我们在后面的编译过程中代码没有报错，而是打印出了0。

这是因为，当代码中没有定义的时候 “int val;” 就不再是声明，而是定义，并且全局变量不初始化的话默认是0.

注意！！！以上这些仅仅针对的是全局变量，而局部变量在声明的时候最好最好对其进行初始化。

到这里，函数就讲解完了，喜欢的话可以点赞、评论和收藏哟!