C语言——函数精讲

时隔多日，小编又前来更新了，接下来将由我进行对函数的讲解！

或许有不少老铁起初，和我有着同样疑问：函数是个啥，函数可以用来做啥…
我们可以把函数理解成一个大的加工厂，对于工厂而言有原材料的输入，原材料的加工，以及产品的输出。我们函数亦是如此！

1. 函数的概念

2. 库函数

3. ⾃定义函数

4. 形参和实参

5. return语句

6. 数组做函数参数

7. 传值调⽤

8. 嵌套调⽤和链式访问

9. 函数的声明和定义

1.函数

C语⾔中的函数就是⼀个完成某项特定的任务的⼀⼩段代码。这段代码是有特殊的写法和调⽤⽅法的。C语⾔的程序其实是由⽆数个⼩的函数组合⽽成的，也可以说：⼀个⼤的计算任务可以分解成若⼲个较⼩的函数（对应较⼩的任务）完成。同时⼀个函数如果能完成某项特定任务的话，这个函数也是可以复⽤的，提升了开发软件的效率。
在C语⾔中我们⼀般会⻅到两类函数：
• 库函数
• ⾃定义函数

2.库函数

2.1库函数的使用，需要引入头文件
像 printf 、 scanf 都是库函数，库函数也是函数，不过这些函数已经是现成的，我们只要学会就能直接使⽤了，他们的使用需引入头文件#include<stdio.h>
2.2对库函数感兴趣的老铁，可自行查阅资料，链接在此
==>
C/C++官⽅的链接：https://zh.cppreference.com/w/c/header
cplusplus.com：https://legacy.cplusplus.com/reference/clibrary/
2.3

double sqrt (double x);
//sqrt 是函数名,表示求平方根
//x 是函数sqrt的参数，表⽰调⽤sqrt函数需要传递⼀个double类型的值
//double 是返回值类型 - 表⽰函数计算的结果是double类型的值

#include <stdio.h>
#include <math.h>
int main()
{
 double d = 16.0;
 double r = sqrt(d);//需要引入<math.h>这个头文件
 printf("%lf\n", r);
 return 0;
}

3.自定义函数

3.1 .1函数的语法形式
其实⾃定义函数和库函数是⼀样的，形式如下：
ret_type fun_name(形式参数)
{

}

• ret_type 是函数返回类型
• fun_name 是函数名
• 括号中放的是形式参数
• {}括起来的是函数体
• ret_type 是⽤来表⽰函数计算结果的类型，有时候返回类型可以是 void ，表⽰什么都不返回
• fun_name 是为了⽅便使⽤函数；就像⼈的名字⼀样，有了名字⽅便称呼，函数有了名字⽅便调⽤，所以函数名尽量要根据函数的功能起的有意义。
• 函数的参数就相当于，⼯⼚中送进去的原材料，函数的参数也可以是 void ，明确表⽰函数没有参数。如果有参数，要交代清楚参数的类型和名字，以及参数个数。
3.1.2函数调用分为2大类：传值调用和传值调用
莫慌，接下来我会讲这二者的区别以及应用

3.2函数应用
浅浅的举个例子吧
写一个函数，完成2个数的相加

#include<stdio.h>
int Add(int x, int y)//实参和形参是一一对应的，即x接收a,y接收b
{
	return x + y;
}
int main()
{
	int a = 0, b = 0;//初始化2个变量
	scanf("%d %d", &a, &b);// 1 3
	int ret = Add(a, b);//进行传参，即传值调用
	printf("%d\n", ret);
	return 0;
}

3.3传值调用
传值调用是个啥？顾名思义，传值调用就是直接将实参的值传递给形参：比如上面那个代码用函数求2数之和
形参和实参的值是一样的，但是函数的形参和实参分别占有不同的内存块，实参是一个独立的空间，形参也是一个独立的空间，只是形参的值与实参的值相同。
3.4传址调用
首先这里的"址“指的是地址；
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式
拿个代码举例，更易理解
比如说，交换2个数

#include<stdio.h>
void swap(int x, int y)
{
	int tmp = 0;//引入中间变量
	tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 0, b = 0;//初始化2个变量
	scanf("%d %d", &a, &b);// 1 3
	printf("交换前;a = %d b = %d\n", a, b);
	swap(a, b);
	printf("交换后;a = %d b = %d\n", a, b);

	return 0;
}
注意：以上是错误写法，小编只是想通过调试，让大家对传值和传址有一个更深刻的理解

通过调试我们发现，实参和形参的地址并不一样，他们都各自指向不同的空间。
要想让函数内部与函数外部建立联系，我们就需要进行传址调用

#include<stdio.h>
void swap(int *x, int *y)//需要用指针接收
{
	int tmp = 0;//引入中间变量
	tmp = *x;
	*x = *y;
	*y = tmp;
}
int main()
{
	int a = 0, b = 0;//初始化2个变量
	scanf("%d %d", &a, &b);// 1 3
	printf("交换前;a = %d b = %d\n", a, b);
	swap(&a,&b);//传址调用
	printf("交换后;a = %d b = %d\n", a, b);

	return 0;
}

通过以上分析，我们可以得出：
形参只是对实参的一份临时拷贝，对形参的修改并不会影响实参的值

4.形参和实参

实际参数就是真实传递给函数的参数。
形参就是在函数名字后面创建的变量名
比如上面的：在函数名 add 后的括号中写的 x 和 y
实际上，如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x和 y 只是形式上存在的，
不会向内存申请空间，不会真实存在的，所以叫形式参数。形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，这个过程就是形式的实例化。

5.return 语句

在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。
• return后边可以是⼀个数值，也可以是⼀个表达式，如果是表达式则先执⾏表达式，再返回表达式的结果。
• return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void的情况。
• return返回的值和函数返回类型不⼀致，系统会⾃动将返回的值隐式转换为函数的返回类型。
• return语句执⾏后，函数就彻底返回，后边的代码不再执⾏。
• 如果函数中存在if等分⽀的语句，则要保证每种情况下都有return返回，否则会出现编译错误。

6.数组做函数参数

在使⽤函数解决问题的时候，难免会将数组作为参数传递给函数，在函数内部对数组进⾏操作。
⽐如：写⼀个函数对将⼀个整型数组的内容，全部置为0，再写⼀个函数打印数组的内容。
这⾥我们需要知道数组传参的⼏个重点知识：
• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组⼤⼩可以省略不写
• 形参如果是⼆维数组，⾏可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的
• 形参操作的数组和实参的数组是同⼀个数组（数组名代表数组首元素的地址）

#include<stdio.h>
void set_arr(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		arr[i] = 0;
	}
}
void print_arr(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9 };//初始化一个一维数组
	int sz = sizeof(arr) / sizeof(arr[0]);//求数组元素个数
	set_arr(arr, sz);//调用set_arr函数
	print_arr(arr, sz);//调用print_arr函数，来打印
	return 0;
}

8. 嵌套调⽤和链式访问

8.1嵌套调⽤：就是函数之间的互相调⽤，正是因为函数之间有效的互相调⽤，最后写出来了相对⼤型的程序
经典例题：假设我们计算某年某⽉有多少天？以函数实现，可以设计2个函数

分析：首先判断这一年是否为闰年（闰年的2 月为29天）即函数is_leap_year(int y)//判断闰年
其次设计一个函数用来判断某月的天数即函数
get_days_of_month(int y, int m)

#include <stdio.h>
int is_leap_year(int y)//判断闰年
{
    if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
    {
        return 1;//是闰年
    }
    else
    {
        return 0;
    }
}
int get_days_of_month(int y, int m)
{
    int days[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };//创建一个保存月份的数组
    int day = days[m];//借助下标访问某月的天数
    if (is_leap_year(y) && m == 2)//是否为闰年二月份
    {
        day += 1;
    }
    return day;


}
int main()
{
    //先判断是否为闰年，因为闰年二月份比较特殊
    //闰年判断;可被4整除但不能被100整除的是闰年，或者，能被400整除的是闰年
//函数调用顺序：main——get_days_of_month(year,month)——is_leap_year(int y
    int year = 0, month = 0;
    while (scanf("%d %d", &year, &month) != EOF)
    {
        int d = get_days_of_month(year, month);//表示某月有多少天
        printf("%d\n", d);


    }
    return 0;
}

• main 函数调⽤ scanf 、 printf 、 get_days_of_month
• get_days_of_month 函数调⽤ is_leap_year
未来的稍微⼤⼀些代码都是函数之间的嵌套调⽤，但是函数是不能嵌套定义的
8.2谓链式访问就是将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数的链式访问。
ok~~,话不多说，上代码

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

要理解下一个代码，关键要get 到 printf 函数的返回是啥？
printf函数返回的是打印在屏幕上的字符的个数。
上⾯的例⼦中，我们就第⼀个printf打印的是第⼆个printf的返回值，第⼆个printf打印的是第三个printf的返回值。
第三个printf打印43，在屏幕上打印2个字符，再返回2
第⼆个printf打印2，在屏幕上打印1个字符，再放回1
第⼀个printf打印1
所以屏幕上最终打印：4321

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

9.函数声明和定义

9.1

#include<stdio.h>
**void swap(int x, int y)
{
	int tmp = 0;//引入中间变量
	tmp = x;
	x = y;
	y = tmp;
}**//函数的定义
int main()
{
	int a = 0, b = 0;//初始化2个变量
	scanf("%d %d", &a, &b);// 1 3
	printf("交换前;a = %d b = %d\n", a, b);
	swap(a, b);//函数调用
	printf("交换后;a = %d b = %d\n", a, b);

	return 0;
}

函数的调⽤⼀定要满足，先声明后使⽤；函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。
9.2多文件
⼀般情况下，函数的声明、类型的声明放在**头⽂件（.h）中，函数的实现是放在源⽂件（.c）**⽂件中。
如下：

**add.c**
//函数的定义
int Add(int x, int y)
{
 return x+y;
}

**add.h**
//函数的声明
int Add(int x, int y);

**test.c**
#include <stdio.h>
#include "add.h"
int main()
{
 int a = 10;
 int b = 20;

9.3static 和 extern
static 和 extern 都是C语⾔中的关键字。
static是 静态的 的意思，可以⽤来：
• 修饰局部变量
• 修饰全局变量
• 修饰函数
extern是⽤来声明外部符号的。
在讲解static和extern之前需要了解⼀下：生命周期和作用域
作用域：限定这个名字的可⽤性的代码范围就是这个名字的作⽤域

1. 局部变量的作⽤域是变量所在的局部范围。
2. 全局变量的作⽤域是整个⼯程。
   ⽣命周期指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的⼀个时间段。
3. 局部变量的⽣命周期是：进⼊作⽤域⽣命周期开始，出作⽤域⽣命周期结束。
4. 全局变量的⽣命周期是：整个程序的⽣命周期
   9.3.1static修饰局部变量
   /代码1

/代码1
#include <stdio.h>
void test()
{
 int i = 0;
 i++;
 printf("%d ", i);
}
int main()
{
 int i = 0;
 for(i=0; i<5; i++)
 {
 test();
 }
 return 0;
}

运行结果：

#include <stdio.h>
void test()
{
	static int i = 0;
	i++;
	printf("%d ", i);
}
int main()
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		test();
	}
	return 0;
}

static修饰局部变量改变了变量的⽣命周期，⽣命周期改变的本质是改变了变量的存储类型，本来⼀个局部变量是存储在内存的栈区的，但是被static修饰后存储到了静态区。存储在静态区的变量和全局变量是⼀样的，⽣命周期就和程序的⽣命周期⼀样了，只有程序结束，变量才销毁，内存才回收。但是作⽤域不变的

static使⽤建议：

如果⼀个全局变量，只想在所在的源⽂件内部使⽤，不想被其他⽂件发现，就可以使⽤
static修饰。
static 修饰函数和static修饰全局变量是⼀模⼀样的，⼀个函数在整个⼯程都可以使⽤，被static修饰后，只能在本⽂件内部使⽤，其他⽂件⽆法正常的链接使⽤了。本质是因为函数默认是具有外部链接属性，具有外部链接属性，使得函数在整个⼯程中只要适当的声明就可以被使⽤。但是被static修饰后变成了内部链接属性，使得函数只能在⾃⼰所在源⽂件内部使⽤。
使⽤建议：⼀个函数只想在所在的源⽂件内部使⽤，不想被其他源⽂件使⽤，就可以使⽤static修饰。

有关函数的相关知识暂时分享到此，后期会不断更新，觉得此篇章ok的话，动动小手给我点个关注呗，蟹蟹！！！！！！