一、函数的概念

数学中我们就学过函数，但是C语言中的函数与此不同，又翻译为：子程序。

C语言中的函数就是完成某一项特定任务的一小段代码。

在C语言中，通常有两种函数：

1.库函数

2.自定义函数

二、库函数

1.标准库和头文件

C语言标准中规定了C语言的各种语法规则，C语言并不提供库函数；C语言的国际标准ANSI C规定了一些常用的函数的标准，被称为标准库，那不同的编译器厂商根据ANSI提供的C语言标准就给出了一系列函数的实现。这些函数就被称为库函数。
之前我们学的printf,scanf等都是库函数，库函数是标准为我们已经实现好的，我们只关心如何使用即可。

各种编译器的标准库中提供了一系列的库函数，这些库函数根据功能的划分，都在不同的头文件中进行了声明。

库函数相关头文件：https://zh.cppreference.com/w/c/header

2.库函数的使用方法

库函数的学习和查看工具很多，比如：
C/C++官方的链接：https://zh.cppreference.com/w/c/header
cplusplus.com：https://legacy.cplusplus.com/reference/clibrary/

举例：sqrt

double sqrt (double x);
//sqrt 是函数名
//x 是函数的参数，表示调用sqrt函数需要传递一个double类型的值
//double 是返回值类型 - 表示函数计算的结果是double类型的值

(1)功能

Compute square root 计算平方根
Returns the square root of x.（返回平方根）

(2)头文件包含

库函数是在标准库中对应的头文件中声明的，所以库函数的使用，务必包含对应的头文件，不包含是可能会出现一些问题的。

三、自定义函数

了解了库函数，我们的关注度应该聚焦在自定义函数上，自定义函数其实更加重要，也能给程序员写代码更多的创造性。

1.函数的语法形式

ret_type fun_name(形式参数)
{
}

ret_type是返回值的类型，若没有返回值则为void

fun_name是函数名

括号中放的是形式参数

{}括起来的是函数本体

我们可以把函数想象成一个工厂，输入的参数就是原材料，当我们传给函数一个参数时，经过函数工厂的加工产出结果就是我们希望函数做的。

例子：加法函数

#include <stdio.h>
int Add(int x, int y)
{
    int z = 0;
    z = x+y;
    return z;
}
int main()
{
    int a = 0;
    int b = 0;
    //输入
    scanf("%d %d", &a, &b);
    //调用加法函数，完成a和b的相加
    //求和的结果放在r中
    int r = Add(a, b);
    //输出
    printf("%d\n", r);
    return 0;
}

Add函数也可以转化为

int Add(int x, int y)
{
    return x+y;
}

2.形参和实参

(1)实参

在上述代码中我们将传递给函数Add的参数a,b称为实际参数，简称实参。其实就是实际传递给函数的参数。

(2)形参

在上面的代码中，在定义函数时，函数名后面括号中的x,y就是形式参数，简称形参。

为什么叫形式参数呢？因为实际上，如果只是定义了函数Add而不去调用的话并不会为x,y开辟空间创建。只有当实际参数a,b传递过来时才会创建。

(3)实参和形参的关系

经过实验调试可以得知实参和形参的内存空间地址是各自独立的。

我们可以理解为形参是实参的一份临时拷贝。

3.return语句

return后面可以是一个数值，也可以是表达式，如果是表达式，则计算出表达式的结果后再返回结果。

return后面也可以是什么都没有，直接写return，这种写法符合返回类型是void的情况。

return返回的值和函数返回的类型不一致，系统会自动将返回的值隐式转换为函数的返回类型。

return语句执行后，函数彻底返回，之后的代码不再执行。

如果函数中存在if等分支语句，则要保证每种情况下都有return返回，否则会编译错误。

4.数组做函数参数

在使用函数解决问题的时候难免会传递数组作为参数。

注意：

函数的形式参数要和参数的实参个数匹配。

函数的实参是数组，形参也是可以写成数组形式的。

形参如果是一维数组，数组的大小是可以不写的。

形参如果是二维数组，行可以省略，但是列不可以省略。

数组传参，形参是不会开辟新数组的。

形参操作的数组和实参操作的数组是同一个数组。

我们可以实现这样的函数：

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

5.嵌套调用和链式访问

(1)嵌套调用

嵌套调用就是函数间的相互调用。

比如：我们计算某年某月有多少天，我们可以设计两个函数

is_leap_year()，根据年份判断是否为闰年

get_days_of_month()，调用is_leap_year()后再按月计算天数

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;
}

(2)链式访问

链式访问就是把一个函数的返回值作为另一个函数的参数，像链条一样串起来就是函数的链式访问。

例如：

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

我们将strlen函数的返回值作为printf函数的参数，打印出字符串的长度。

6.函数的声明和定义

(1)单个文件

上面的代码中，我们将函数定义出来就直接调用了。但是，如果我们将函数定义在调用之后。

比如：判断是否为闰年的函数

#include <stido.h>
int main()
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);
    if(r == 1)
    printf("闰年\n");
    else
    printf("非闰年\n");
    return 0;
}
//判断一年是不是闰年
int is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)) || (y%400==0))
    return 1;
    else
    return 0;
}

这是如果直接编译，会出现编译报错，提示我们找不到is_leap_year这个函数。因为当运行到调用is_leap_year函数时编译器并没有将函数的定义加载到内存。那么，我们该如何解决这个问题呢？

其实只需要再主函数前声明一下这个函数就可以了。

#include <stido.h>

int is_leap_year(int y)；//函数声明

int main()
{
    int y = 0;
    scanf("%d", &y);
    int r = is_leap_year(y);
    if(r == 1)
    printf("闰年\n");
    else
    printf("非闰年\n");
    return 0;
}
//判断一年是不是闰年
int is_leap_year(int y)
{
    if(((y%4==0)&&(y%100!=0)) || (y%400==0))
    return 1;
    else
    return 0;
}

这样就相当于告诉编译器，我实现了这个函数，只是放在了调用函数的下面，此时当运行到 int r = is_leap_year(y); 时编译器就会自动地去下面寻找这个函数。

所以，函数要先声明后使用，函数的定义也是一种特殊的声明，所以如果函数定义放在调用之前也是可以的。

(2)多个文件

一般我们在企业中写代码的时候，代码会比较多，所以我们会将代码分在不同的多个文件中。

一般情况下，函数的声明、类型的声明放在头文件(.h)中，函数的实现是放在源文件(.c)文件夹中。

如下:

Add.c

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

Add.h

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

7.static和extern

static和extern都是c语言中的关键字。static是静态的意思，可以用来：

修饰局部变量

修饰全局变量

修饰函数

extern是用来声明外部符号的。

在讲解static和extern之前再讲解一下：作用域和声明周期

作用域是程序设计的概念，通常来说，一段程序代码中所用到的名字并不做事有效(可用)，而限定这个名字的代码范围就是作用域。

局部变量的作用域就是：变量所在的局部范围。

全局变量的作用域就：是整个项目。

生命周期就是变量的创建(申请内存)到变量的销毁(回收内存)之间的一个时间段。

局部变量的生命周期是：进入作用域变量创建，生命周期开始，出作用域生命周期结束。

全局变量的生命周期是：整个程序的生命周期。

(1)static修饰局部变量

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

使用建议：未来一个变量出了函数后，我们还想保留值，以便下次进入函数的时候继续使用，就可以用static修饰。

 (2)static修饰全局变量

一个全局变量被static修饰后，是这个全局变量只能在本源文件内使用，不能在其他源文件内使用。

本质原因是全局变量默认是具有外部链接属性的，在外部的文件中想使用，只要适当的声明就可以用；但是全局变量被static 修饰之后，外部链接属性就变成了内部链接属性，只能在自己所在的源
文件内部使用了，其他源文件，即使声明了，也是无法正常使用的。

使用建议：如果一个全局变量只想在源文件内部使用，不想让其他文件看到这个变量，就可以使用static修饰。

(3)static修饰函数

static 修饰函数和static 修饰全局变量是一模一样的，一个函数在整个工程都可以使用，
被static修饰后，只能在本文件内部使用，其他文件无法正常的链接使用了。

使用建议：一个函数只想在所在的源文件内部使用，不想被其他源文件使用，就可以使用 static 修
饰.