数学中有函数的概念，比如：一次函数y=kx+b，给一个任意x，得到一个y值
C语言中的函数(有些翻译为：子程序)就是⼀个完成某项特定的任务的⼀小段代码，这段代码是有特殊的写法和调用方法的。一般有两类函数:库函数，自定义函数。
C语言的程序其实是由无数个小的函数组合而成的，因此一个大的计算任务可以分解成若⼲个较小的函数（对应较小的任务）完成。
一、库函数
C语言并不提供库函数；C语言的国际标准ANSI C规定了⼀些常用的函数的标准（比如他们的功能参数返回类型……），被称为标准库，那不同的编译器⼚商根据ANSI提供的C语⾔标准就给出了⼀系列函数的实现。这些函数就被称为库函数，使用库函数能大大提升效率。
double sqrt (double x);
//sqrt 是函数名
//x 是函数的参数，表⽰调⽤sqrt函数需要传递⼀个double类型的值
//double 是返回值类型 - 表⽰函数计算的结果是double类型的值
同时库函数根据功能的划分，都在标准库中对应的头文件中进行了声明,所以库函数的使用必须包含对应的头文件。 比如库函数sqrt,功能是返回平方根,必须包含对应的头文件即math.h
#include <stdio.h>
#include <math.h>//使用库函数必须包含对应的头文件
int main()
{
double d = 16.0;
double r = sqrt(d);
printf("%lf\n", r);
return 0;
} 可以从以下网站查看对应的库函数
C/C++官方的链接：https://zh.cppreference.com/w/c/header
cplusplus.com：https://legacy.cplusplus.com/reference/clibrary/
二、自定义函数
语法形式
ret_type fun_name(形式参数)
{
}① ret_type是函数返回类型,用来表示函数计算结果的类型,返回类型可以是 void ,表示什么都不返回
②fun_name 是函数名,方便调用。
③ 括号中放的是形式参数,函数的参数也可以是 void ,表示函数没有参数。如果有参数，要交代清楚参数的类型和名字，以及参数个数。
④ {}括起来的是函数体，是完成计算的过程。
函数的参数部分需要交代清楚：参数个数，每个参数的类型，形参的名字。
方便理解可以将函数假想为加工厂，工厂(函数)得输入原材料(参数)，经过工厂加工才能生产出产品(函数计算结果)
例如:写⼀个加法函数，完成2个整型变量的加法操作
思路:调用加法函数,取名:Add,Add会接收2个整型类型的参数a,b,用整形的值x,y接收,函数计算的结果也是整型,也就是把x+y的和即结果返回z，类型int,所以Add的返回类型是int,此时z就是结果r
#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;
}2.1、形参和实参
函数使用的过程中，把函数的参数分为，实参和形参。
调用Add函数时，传递给函数的参数a和b，称为实际参数，简称实参。实际参数就是真实传递给函数的参数。
在函数名Add后括号中写的x,y就是形式参数，简称形参，因为只是定义了 Add 函数，未调用 ,Add 函数的参数 x和 y 只是形式上存在，不会向内存申请空间，不会真实存在，所以叫形式参数。形式参数只有在函数被调用的过程中为了存放实参传递过来的值，才向内存申请空间，这个过程就是形参的实例化。
实参是传递给形参的，他们之间是有联系的，但是形参和实参各自是独立的内存空间。
#include <stdio.h>
int Add(int x, int y)//函数定义时，函数名后边的参数就是函数的形式参数，简称形参(x和y)
{
int z = 0;
z = x+y;
return z;
}
int main()
{
int a = 0;
int b = 0;
//输⼊
scanf("%d %d", &a, &b);//在函数调用的时候，真实传涕给函数的参数，就是实参一实际参数(a和b)
//调⽤加法函数，完成a和b的相加
//求和的结果放在r中
int r = Add(a, b);
//输出
printf("%d\n", r);
return 0;
}
输入a,b为10和2后经调试发现xy和n1,n2不是一样的地址，说明传参过去的时候，xy为了准备接受传过去的n1和n2的值，确实也是付出了代价，各自也创建了空间,但是确实把值传过去了，n1给了x,n2给了y,但是自己有独立的空间， 最后12通过return的方式传回来，用r去接收，更细的说，先传给寄存器(方便计算，在电脑上的一种快速存储的空间)作为中转，返回后再传给r
形参是实参的一份临时拷贝，形参是有自己独立的空间，对形参的修改，不会影响实参的
总结:
1. 形参的名字和实参名可以相同
2．形参的个数可以是0、也可以有1个或者多个
3．形参的个数和实参要匹配上，即实参没有形参也没有。
4 . 形参是实参的⼀份临时拷贝,有自己独立的空间。
2.2、return语句
1、 return后边可以是一个数值，也可以是⼀个表达式，如果是表达式则先执行表达式，再返回表达式的结果。
2、return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void(即没有返回的类型)的情况。写了void，需不需要返回取决于程序员自己,void函数加return语句有一种情况是必须的，不想执行后面的语句就返回调用函数的。
3、return返回的值和函数返回类型不⼀致，系统会自动将返回的值隐式转换为函数的返回类型。
4、 return语句执行后，函数就彻底返回，后边的代码不再执行。
5、 如果函数中存在if等分支的语句，则要保证每种情况下都有return返回，否则会出现编译错误。
6、如果一个函数有明确的返回类型，但是函数内部没有return返回值，最终到底返回什么值，是不确定的！
7、函数的返回类型如果不写的话，编译器会默认他返回的是int类型。比如test(),默认int test()
第3条可以这样理解:返回值3.4和函数返回类型int,不一致,先把3.4转换成int类型再返回,r接收3
#include<stdio.h>
int test()
{
return 3.4;
}
int main()
{
int r = test();
printf("%d", r);
return 0;
}
第4条可以这样理解：此时什么都不返回，不执行hehe
void print(int n)
{
if (n < 0)
return;
printf("hehe");
}
int main()
{
print(-1);
return 0;
}第5条可以这样理解,函数内部无返回值,返回值不确定
#include<stdio.h>
int test()
{
printf("hehe\n");
int c = 0;
c = 3 + 5;
}
int main()
{
printf("%d\n", test());
return 0;
}
关于main函数的返回值这里要注意:
①main函数也是函数,
②main函数也是被编译器指定的一个函数调用了
③return0，就是将0返回给调用main函数的那个函数。
④main函数中返回0表示正常返回，返回非0值表示异常返回
2.3、数组做函数参数
数组作为参数传递给函数，需要给函数传递两个参数，一个是数组，另外⼀个是数组的元素个数，因为函数内部在设置数组每个元素的时候,也得遍历数组，需要知道数组的元素个数。
例如:设置数组元素为-1，并打印出来
#include<stdio.h>
void set_arr(int arr[], int sz)
{
int i = 0;
for(i=0; i<sz; i++)
{
arr[i] = -1;
}
}
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]);//数组元素个数
set_arr(arr, sz);//设置数组内容为-1，传递数组和数组元素个数
print_arr(arr, sz);//打印数组内容
return 0;
} 
1、给了数组，形参设置成数组的形式，这里大小不需要写。
2、若要在set_arr中修改数组，其实就是修改主函数中的arr。
解释如下：数组传参，其实传递的是数组的地址，将arr的地址传递过去，在形参部分访问数组的时候，其实操作的就是主调函数中的数组，依然是使用传过去的地址，找回来并使用arr数组即set_arr()使用的数组就是main里的数组，而且数组传参的时候，在形参的部分不会新建数组，所以不需要数组的大小。
数组传参总结:
函数的形式参数要和函数的实参个数匹配
函数的实参是数组，形参也是可以写成数组形式的
形参如果是一维数组，数组大小可以省略不写
形参如果是二维数组，行可以省略，但是列不能省略
数组传参，形参是不会创建新的数组的
形参操作的数组和实参的数组是同一个数组
2.4、嵌套调用和链式访问
2.4.1嵌套调用
嵌套调用就是函数之间的互相调用,多个函数之间有效的嵌套调用,可以写出相对大型的程序。
但是不能把一个函数不能定义在另一个函数内。
例: 假设我们计算某年某月有多少天？
思路:如果要函数实现，可以设计2个函数:
is_leap_year()：根据年份确定是否是闰年，能被4整除同时不能被100整除或者能被400整除
get_days_of_month()：调用is_leap_year确定是否是闰年后，再根据月计算这个月的天数(采用数组的形式)
main 函数调用 scanf 、 printf 、 get_days_of_month
get_days_of_month 函数调用 is_leap_yea
#include<stdio.h>
int is_leap_year(int year)
{
if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
{
year = 1;
}
else
year = 0;
//return ((year % 4 == 0 && year % 100 != 0)) || (year % 400 == 0)
return year;
}
int get_days_of_month(int year, int month)
{
int arr[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
int day = arr[month];
if (is_leap_year(year) && month == 2)
{
day++;
}
return day;
}
int main()
{
int year = 0;
int month = 0;
scanf("%d %d", &year, &month);
int day = get_days_of_month(year, month);
printf("%d",day);
return 0;
}2.4.2、链式访问
链式访问就是将⼀个函数的返回值作为另外⼀个函数的参数,像链条一样串起来
#include <stdio.h>
int main()
{
int len = strlen("abcdef");//1.strlen求⼀个字符串的⻓度
printf("%d\n", len);//2.打印⻓度
return 0;
}比如把strlen的返回值直接作为printf函数的参数
#include <stdio.h>
int main()
{
printf("%d\n", strlen("abcdef"));//链式访问
return 0;
}比如printf函数返回的是打印在屏幕上字符的个数
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
return 0;
} 这里第⼀个printf打印的是第⼆个printf的返回值，第⼆个printf打印的是第三个printf的返回值。
第三个printf打印43，在屏幕上打印2个字符，再返回2
第二个printf打印2，在屏幕上打印1个字符，再返回1
第一个printf打印1
所以最后打印4321
2.5、函数的声明和定义
2.5.1、单个文件内：
将函数的定义放在调用前面时，无需声明。
#include <stido.h>
//判断⼀年是不是闰年
int is_leap_year(int y) //函数定义
{
if(((y%4==0)&&(y%100!=0)) || (y%400==0))
return 1;
else
return 0;
}
int main()
{
int y = 0;
scanf("%d", &y);
int r = is_leap_year(y); //函数调用
if(r == 1)
printf("闰年\n");
else
printf("⾮闰年\n");
return 0;
} 将函数的定义放在函数的调用前面时，无需声明，因为函数的定义也是⼀种特殊的声明
将函数的定义放在函数的调用后边，需要声明，不然会报错，因为编译器对源代码进⾏编译的时候，从第一行往下扫描的时候没有发现没有发现前⾯有is_leap_year的定义，需要先声明⼀下is_leap_year这个函数，声明函数只要交代清楚：函数名，函数的返回类型和函数的参数，
即int is_leap_year(int y)；这就是函数声明，函数声明中参数只保留类型，省略掉名字也是可以的
因此函数的调用⼀定要满足，先声明后使用。
#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;
}
2.5.2、多个文件：
当代码比较多的时候，需要根据程序的功能，将代码拆分放在多个文件中，这样的好处是
1、方便协作2、模块化，代码可以复用3、一定程度对代码进行隐藏
一般情况下，函数的声明、类型的声明放在头文件（.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;
//函数调⽤
int c = Add(a, b);
printf("%d\n", c);
return 0;
} 
2.5.3、static和extern
static：C语言中的关键字之一，是静态的意思，
作用为：1、修饰局部变量2、修饰全局变量3、 修饰函数
extern：C语言中的关键字之一，是外部的意思，作用是声明外部符号，如果一个全局的符号在A文件中定义的，在B文件中想使用，就可以使用extern 进行声明，然后使用。
需要先了解作用域和生命周期：
作用域(scope):程序设计概念，通常来说,一段程序代码中所用到的名字并不总是有效(可用），而限定这个名字的可用性的代码范围就是这个名字的作用域。
1. 局部变量的作用域是变量所在的局部范围。
2. 全局变量的作用域是整个工程（项目）。
#include<stdio.h>
int main()
{
{
int a = 0;//局部变量a
printf("1:a=%d\n", a);//这里a的作用域只有大括号内，a的生命周期从从创建a到出大括号为止
}
printf("2:a=%d\n", a);//这里a不发生作用，所以会报错，若想正常，需创建全局变量
test();
return 0;
}#include<stdio.h>
int a = 10;//全局变量a，a的生命周期是从main函数开始运行到结束。
void test()
{
printf("3:a = %d\n", a);
}
int main()
{
{
printf("1:a = %d\n", a);
}
printf("2:a = %d\n", a);
test();
return 0;
}
生命周期：变量的创建(申请内存)到变量的销毁(收回内存)之间的一个时间段。
1. 局部变量的生命周期是：进⼊作用域变量创建,生命周期开始,出作用域生命周期结束。
上述例子a的生命周期是从创建a到出大括号为止 。
2. 全局变量的生命周期是：整个程序的生命周期。上面的例子a的生命周期是从main函数开始运行到结束。
2.5.3.1修饰局部变量：
static修饰局部变量是改变了变量的生命周期，因为生命周期改变的本质是改变了变量的存储类型，本来一个局部变量是存储在内存的栈区的，但是被 static 修饰后存储到了静态区。存储在静态区的变量和全局变量是⼀样的，生命周期就和程序的生命周期⼀样了，只有程序结束，变量才销毁，内存才回收。但是作用域不变的。
//代码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;
} 
代码1的test函数中的局部变量i是每次进⼊test函数先创建变量（生命周期开始）并赋值为0，然后++,再打印,出函数的时候变量生命周期将要结束（释放内存）,每次进入函数，i都要重新创建
//代码2
#include <stdio.h>
void test()
{
//static修饰局部变量
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for(i=0; i<5; i++)
{
test();
}
return 0;
代码2中，从输出结果来看，i的值有累加的效果，其实test函数中的i创建好后，出函数的时候是不会销毁的，重新进⼊函数也就不会重新创建变量，直接上次累积的数值继续计算。好像延长了生命周期，进去出来后都能用，但其实是加了static从栈区到了静态区,生命周期变长了，和全局变量在一起了。
因此static修饰的变量可以改变，让他的变长了生命周期，以后⼀个变量出了函数后，我们还想保留值，等下次进⼊函数继续使用，就可以使用static修饰
2.5.3.2 修饰全局变量
全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使⽤。本质原因是全局变量默认是具有外部链接属性(跨文件可以使用)的，在外部的文件中想使用，只要适当的声明就可以使用；但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性(不能跨文件使用)，只能在自己所在的源文件内部使用了，其他源文件，即使声明了，也是无法正常使用的
代码1：
add.c
int g_val = 2018;test.c
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
代码2
static int g_val = 2018;
test.c
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
编译错误，加了static导致不能跨文件使用。
头文件的包含解决的也是声明的问题,可以用头文件解决，也可以采用extern的方式声明,也就是跨文件使用时可以使用extern,声明外部函数时参数类型个数需交代清楚,参数的名字可以不写。
此时代码1正常，代码2在编译的时候会出现链接性错误。
因此:如果⼀个全局变量,只想在所在的源文件内部使用,不想被其他文件发现,就可以使用static修饰
2.5.3.3修饰函数
static 修饰函数和 static 修饰全局变量是一模一样的，一个函数在整个工程都可以使用，被static修饰后，只能在本⽂件内部使用，其他文件无法正常的链接使用了。本质是因为函数默认是具有外部链接属性，具有外部链接属性，使得函数在整个工程中只要适当的声明就可以被使用。但是被 static 修饰后变成了内部链接属性，使得函数只能在自己所在源文件内部使用。
代码1：
add.c
int Add(int x, int y)
{
return x+y;
}test.c
#include <stdio.h>
extern int Add(int x, int y);//声明外部函数时类型个数需交代清楚，类型可以不写
int main()
{
printf("%d\n", Add(2, 3));
return 0;
} 
代码2
static int Add(int x, int y)
{
return x+y;
}
test.c
#include <stdio.h>
extern int g_val;
int main()
{
printf("%d\n", g_val);
return 0;
}
因此⼀个函数只想在所在的源文件内部使用,不想被其他源文件使用,就可以使用 static 修饰。
3760
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
