目录
一.函数概念
1.函数又叫子程序
*C语言的程序其实是由无数个小的函数组合而成的；比如说：贪吃蛇由500行代码组成，这500行代码都是拆分成一个一个函数存在的，因为功能比较复杂，拆分一个一个功能。
(1) 一小段代码，不会特别长。
(2) 完成某项特定的任务。
所以一个大的计算任务可以分解成若干个较小的函数（对应较小的任务）完成。同时一个函数如果能完成某项特定任务的话，这个函数也是可以复用的，提升了开发软件效率.
2. 函数的好除
(1) 可以拆分任务
(2) 可以复用，提升开发效率//写好了一个函数可以复用它，它可以用，你也可以用。
3.函数分类
1.库函数是现成的，可以直接使用。
2.自定义函数是根据需要，自己创造的函数。
二.库函数的了解
1.认识库函数
(1) C语言规定了语法规则
(2) C语言本身不提供库函数
(3) 但是C语言规定了，一些库函数的各种信息；比如：
scanf - 名字 ，参数 ，返回类型，函数的功能...C语言自己不去实现,让C语言编译器的厂商根据规定来实现这些函数
printf -
......
微软 - MSVC - 微软的团队就实现对应的库函数。
苹果 - clang - 苹果的团队就实现对应的库函数。
2. 学习网站
*库函数相关头⽂件：https ://zh.cppreference.com/w/c/header
库函数的学习和查看⼯具很多，⽐如：
C / C++官⽅的链接：https ://zh.cppreference.com/w/c/header
cplusplus.com：https ://legacy.cplusplus.com/reference/clibrary/
3..如何自己学习库函数
在网站对应下面格式看文档
（1）函数原型
（2）函数的功能介绍
（3）参数和返回类型说明
（4）代码列举
（5）代码输出
（6）相关知识链接/功能差不多一样的库函数
总结1：
1.库函数的实现细节可能有差异，但是程序员使用的时候，基本无感。
2.如果有些功能库函数是能够完成的，自己就不要尝试实现类似的功能，你写的功能可能有bug，而且程序执行的效率可能没库函数这么好。
3.库函数是在标准库中对应的头⽂件中声明的，所以库函数的使⽤，务必包含对应的头⽂件，不包含是可能会出现⼀些问题的。
4.库函数的学习不用着急一次性全部学会，慢慢学。
三.自定义函数(重点)
⾃定义函数其实更加重要，根据需求创建，也能给程序员写代码更多的创造性。库函数并不能完成所有任务，库函数把所有问题解决了还要程序员干什么。
1.函数的语法形式
//其实⾃定义函数和库函数是⼀样的，形式如下：
1ret_type fun_name(形式参数)
2{
3 //大括号里面的是函数体，描述的是函数完成任务的过程
4}
//这只是格式 ret_type 是函数返回类型
• fun_name 是函数名
• 括号中放的是形式参数
•{}括起来的是函数体
2 函数的举例
举个例⼦：
写⼀个加法函数，完成2个整型变量的加法操作。完成2个整形的相加，要传进来2个整形类型值。
int Add(int x, int y)//我们自己创建的函数的叫函数定义
//x接收a，y接收b，a，b都是int类型也要用2个int类型接收
{
int z = 0;
z = x + y;
// return x + y；这种写法直return直接把算出的结果返回。
return z;把z的结果返回到sum里面去，返回z的类型是int类型，函数Add也要用int类型
}
int main()
{
int a = 0;
int b = 0;
int sum = 0;//sum变量存的Add这个函数返回的结果
scanf("%d %d", &a, &b);
//求和这个功能分装成个函数
int sam = Add(a, b);//这里是函数调用，调用或使用这个函数
//Add这个函数想让2个数相加必须得传参。调用的时候传2个参数
printf("%d\n", sum);
return 0;
}int Add(int x, int y)//我们自己创建的函数的叫函数定义
//x接收a，y接收b，a，b都是int类型也要用2个int类型接收
{
return x + y；这种写法直return直接把算出的结果返回。
}
这种写法也能返回最终的值
总结2
1.函数名是自定义的，根据实际情况起名字。
2.参数的个数也算根据实际情况来确定，可以有0个参数，也可以有多个参数。
3.函数的返回值，函数可以返回值，也可以不返回，要根据实际情况来写。
4.函数不返回值的时候，返回类型写void
四.形参和实参
1.申明是实参和形参
在函数使用过程中，把函数的参数分为，实参和形参。
int Add(int x, int y) 形式参数，简称：形参
*如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x和 y 只是形式上存在的，
不会向内存申请空间，不会真实存在的，所以叫形式参数。形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，//这个过程就是形式的实例化。
int Add(int x, int y)//形式参数，简称：形参
//一整个函数叫 函数定义
return x + y;
}
int main()
{
int a = 0;
int b = 0;
int sum = 0;
scanf("%d %d", &a, &b);
int sam = Add(a, b);//函数调用,a和b真实传给函数的参数，他们叫实际参数，简称：实参。
//理解为函数调用时，传递给函数的参数就是实参
printf("%d\n", sum);
return 0;
}补充：心得
要使用必须调用，不一定要先定义，因为可以在.h头文件定义，然后再在其它源文件.c，实现你定义的功能，我们使用调用一下就ok了。
2.实参和形参的关系
4.3实参和形参的关系
补充：
X86 表示32位环境 - 编译生成的32位的程序//这个更好观看内存地址
X64 表示64位环境 - 编译生成的64位的程序
形参和实参各⾃是独⽴的内存空间
当我们创建变量a的时候会向内存申请一块空间，放入值；当我们函数调用的时候，也会创建接x接收a传来的真实参数，这个过程叫实例化；
实参和形参不是同一块空间的，内存地址不一样，
(1) 当实参传给形参的时候，形参是实参的一份临时拷贝。
(2) 对于形参的修改，是不会改边实参的。
五.return语句
1.特点和注意事项 5
在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。
(1) return后边可以是⼀个数值，也可以是⼀个表达式，如果是表达式则先执⾏表达式，再返回表达式的结果。
int fufu(int a)
{
if (a % 2 == 1)
{
return 1;//return 可以返回数值或表达式
}
else
{
return 0;
}
}
int main()
{
int a = 0;
scanf("%d", &a);
int b = fufu(a);
if (b == 1)
printf("奇数");
else
printf("偶数");
return 0;
}(2) return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void的情况
//写一个函数打印1-n的数字;这个代码写的时候思考全面要是输入-1咋办，代码不知道做什么了就蒙蔽了
void Add(int n)
{
if (n < 1)
{
return;//只返回不带会任何值；函数提前返回，提前结束
//这里不能用break，break是打破循环的，不能打破函数
}
int i = 0;
for (i = 1; i <= n; i++)
{
printf("%d ", i);
}
}
int main()//main函数用来表示代码没问题才返回0
{
int m = 0;
scanf("%d", &m);
Add(m);
return 0;
}
(3)return返回的值和函数返回类型不⼀致，系统会⾃动将返回的值隐式转换为函数的返回类型。
(3)
//函数前面是什么类型就返回什么类型
int fufu(int c)//函数这里是int类型，会把return返回的值强行转换成int类型。
{
return c;//要是这里c = 3.5 函数fufu是int类型；会把小数去掉返回3
}
int main()
{
int c = 0;
scanf("%d", &c);
//创建一个op变量，接收函数fufu返回来的值。
int op = fufu(c);//函数调用
printf("%d", c);
return 0;
}4 // return语句执⾏后，函数就彻底返回，后边的代码不再执⾏
(4)如果函数中存在if等分⽀的语句，则要保证每种情况下都有return返回，否则会出现编译错误。
(4)
int rest()
{
int n = 0;
scanf("%d", &n);
if (n % 2 == 1)
{
return 1; //如果if为真就返回1;但是得考虑为假返回几。
}
else
return 0;
}
int main()
{
int a = rest();
printf("%d\n", a);
return 0;
}总结3
（1）函数的返回类型
1.函数的返回类型可以是char，int，short，double……这些内置类型，也可以是自定义类型组，结构体，枚举，联合体。
2.函数的返回类型也可以是void ，void的意思就是函数不需要返回值，也不返回值。
3.函数需不需要返回值，是根据实际的情况设计的；不是别人告诉你要或不要。你希望有返回类型，那就设计。
（2）函数参数
1.函数的参数可以有0个，也可以有多个，这个根据实际需要来确定
2.参数的类型只要合法的类型，char，int，flaot，double……内置类型，也可以是自定义类型
3.函数的参数如果是0个，也就是不需要参数的时候，//函数的参数类型可以写成void，void在这里表示函数没有参数，也不需
1.举例：函数参数（3）
void test(void)//这里写void意思是明确告诉编译器我不许要参数，只要函数调用传参就报警告
{
printf("hehe\n")；
}
int main()
{
test();//函数调用
test(1);//函数调用
test(100);//函数调用
test(100,200);//函数调用
//test函数没有形参接收，但是实参依然可以传参，只不过没有变量接收它，你调用的时候可以传参
//但c语言这样写法不太合理，明明没有参数你还能给我传参，结果还对了，避免这种方式形参里面写void
return 0;
}2种情况
1.函数调用了4次所以打印hehe
2.形参里面是void，函数调用里面有参数会报警告
2.举例：函数的返回类型如果什么都不写，默认函数的返回类型是int
void test(void)//2.函数类型写void明确函数不需要返回，拿int a 接收返回值就报警高了
{
printf("hehe\n");
}
int main()
{
int a = test();
printf("%d", a);//1.打印5，是随机打印的
return 0;
}2种情况
1.函数需要返回类型，你没写默认函数返回int类型，接收它返回来的值，打印是5，明明打印的字符，为啥是5，因为随机的。
2.给函数类型类型写void，明确告诉编译器不需要返回类型，你创建变量去接收就会报警告。
六.数组作为函数参数
1.数组函数特点
(1) 实参和形参的名字可以相同
(2) 数组传参写的是数组名//数组去掉名字，是这个数组的类型比如 int [], float [].
(3) 形参写的也是数组形式，并且在形参书写的时候可以省略元素个数//(指的一维数组)
(4) 数组传参后, 形参的数组和实参数组是同一块空间，改变形参的数组就是在修改实参数组(为什呢？)
2.直接上题学习数组
想把数组传给函数，就把数组作为函数参数
题目：写一个函数将一个和整形的内容，全部设置为 - 1，再写一个函数打印数组的内容。
(1) 通过题目知道自己要创建2个函数
(2) set_arr()用于将数组元素设置为-1
(3) print_arr()打印数组所有内容
void print_arr(int arr1[], int sz1)//设置这个函数的值，不用返回
{
int a = 0;
for (a = 0; a < sz1; a++)
{
printf("%d ", arr1[a]);
}
printf("\n");
}
void set_arr(int arr2[], int sz1)//设置这个函数的值，不用返回
{
int a = 0;
for (a = 0; a < sz1; a++)
{
arr2[a] = -1;
}
}
int main()
{
int arr1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sz1 = sizeof(arr1) / sizeof(arr1[0]);//传给形参的元素个数
print_arr(arr1, sz1);//改之前，打印一次，改之后打印一次；这就是函数复用
set_arr(arr1, sz1);//数组传参写的是数组名，不是arr[10]这是数组第11个元素
print_arr(arr1, sz1); //打印数组所有内容
return 0;
}
补充心得
区分
arr[10]这是指大小
arr[10]函数调用里面这样写是指下标数组第11个元素
总结4：数组传参的⼏个重点知识
• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组⼤⼩可以省略不写，写了也是摆设
• 形参如果是⼆维数组，⾏可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的//实参传给形参的数组，是同一个数组，地址没发生变化，不会创建新的数组；这里注意和其它内置类型传参的区别
• 形参操作的数组和实参的数组是同⼀个数组//函数改变形参的数组其实是改变实参的数组
根据上述的信息，我们就可以实现这两个函数：
七.嵌套调用和链式访问
1.嵌套调用
嵌套调⽤就是函数之间的互相调⽤，每个函数就⾏⼀个乐⾼零件，正是因为多个乐⾼的零件互相⽆缝
的配合才能搭建出精美的乐⾼玩具，也正是因为函数之间有效的互相调⽤，最后写出来了相对⼤型的程序
(1)练习
假设 : 我们计算某年某月有多少天？如果要函数实现，可以以设计2个函数//计算某2020年2月有多少天
闰年的判断
1.能被4整除，并且不能被100整除
2.或能被400整除
int is_leap_year(int x)
{
if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0)
return 1;//如果为真返回1
else
return 0;//如果为假返回0
}
int get_days_of_month(int x, int y)//接收类型是整形，所以函数是整形，要返回一个值
{
int days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };//创建一个每个月天数的数组
// 0 1 2 3 4 5 6 7 8 9 10 11
//2.因为下标是0开始的，要用下标对应月，所以下标-1
int day = days[y - 1];
//因为2月是特殊的要判断是不是闰年 - 29天
//3.在这个函数里面再嵌套一个函数，也相当于再创建一个函数去判断是不是闰年
if（is_leap_year(x) && y == 2)//判断这个函数是不是真
{
day++;
}
return day;
}
int main()
{
int year = 0;//年的变量
int month = 0;//月的变量
scanf("%d %d", &year, &month);//输入2020 2
//1.自定义一个函数，计算某年某月有多少天，用个变量接收
int d = get_days_of_month(year, month);
printf("%d", d);
return 0;
}
2.链式访问
将一个函数的返回值作为另外一个函数的参数，像链条一样将函数串起来就是函数的链式访问。
(1)练习
int main()
{
printf("%d", printf("%d", printf("%d", 43)));//4321
printf("%d ", printf("%d ", printf("%d ", 43)));//43 3 2
return 0;
}1.printf返回值是字符总个数，就是在屏幕上打印的几个字符
2.如果%d用空格隔开也会打印一个空白字符个数
*3.可以这样写把一个函数的返回值作为另外一个函数的参数，但不要列的太长了
八.函数的声明和定义
*这个玩意非常重要。
1.单个文件 ，用函数怎么写？
这里假如写个判断闰年的函数
函数声明 - 告诉编译器函数的名字，参数，返回类型
int is_leap_year(int x);只要在使用之前声明，函数声明只要告诉，函数名，参数，返回类型是什么加分号。
错误示范，应该要把函数定义写在主函数上面
int main()
{
int year = 0;
scanf("%d", &year);
int c = is_leap_year(year);//函数调用
if (c == 0)
{
printf("是闰年\n");
}
else
printf("不是闰年\n");
return 0;
}
//函数定义
int is_leap_year(int x);
{
if (x % 4 == 0 && x % 100 != 0 || x % 400 == 0)
return 1;//如果为真返回1
else
return 0;//如果为假返回0
}总结5
//1.因为编译器编译代码的时候，会对代码进行扫描，扫码从第一行往后扫码的~
//2.它从前面扫码发现了函数定义，它认识了，然后他会往后扫描，看见这个地方要函数调用，它就知道这里要调用刚刚扫码的函数。
//3.如果你把函数定义放在后面，它扫描到这个地方要函数调用，它就会报警告，函数未定义，但是强行执行也可以
//4c语言中要求函数，先声明后使用
//5.只要在使用之前声明，函数声明只要告诉，函数名，参数，返回类型是什么加分号,也可以把函数定义放在后面。
//6.函数定义放在前面也没需要声明，函数定义 - 是一种特殊的声明，因为函数定义这玩意太比函数声明nb太多了，不仅仅告诉你有函数，怎么实现都告诉你。本身就是声明 定义。
//7.函数定义放在main函数后面使用，要先在前面声明。
2.多个文件
⼀般在企业中我们写代码时候，代码可能⽐较多，不会将所有的代码都放在⼀个⽂件中；我们往往会根据程序的功能，将代码拆分放在多个⽂件中。
⼀般情况下，函数的声明、类型的声明放在头⽂件（.h）中，函数的实现是放在源⽂件（.c）⽂件中。
总结6
1.这种才是企业是代码的方式。
2.把函数定义，实现的功能写在一个创建的源文件，把函数的声明，写在一个创建的头文件。
3.我门要使用这个函数功能的时候包含一下头文件，自己创建的头文件使用双引号，也相当于函数声明。
分模块写代码的好处：
1.逻辑清晰。
2.方便协助，假如10个程序员写代码，一个文件不够。
3.方便隐藏代码。一个模块有拆分.c和.h文件，是为了代码隐藏。只给你看.h文件不给你看.c文件你就不知道这个函数功能如何实现，只能使用。
可以把实现功能的.c源文件设置成静态库，我们使用的时候 导入静态库
九.static和extern
1.static 和 extern 都是C语⾔中的关键字。
static 是 静态的 的意思，可以⽤来：
1.修饰局部变量
2.修饰全局变量
3.修饰函数
extern 是⽤来声明外部符号的。
2.作用域
一个变量在哪里使用，哪里就是作用域，能够使用的区域，就是作用域。
int c = 100;//全局变量，想在哪里使用就在哪里使用，创建的函数都行。
void test()
{
printf("c = %d", c);
}
int main()
{
int a = 0;
int b = 20;//局部变量
for (a = 0; a <= 10; a++)
{
int i = 10;//这个i的作用域就是创建这个大括号的局部范围，局部变量
printf("i = %d", i);//只能在这里面使用
printf("b = %d", b);//因为b这个变量在main函数里面的大括号，它包含了里面的大括号，可以在其它大括号 使用
}
printf("i = %d", i);//当把创建里面的变量拿出来用不行
return 0;
}1.局部变量的作用域是变量所在的范围
2.全局变量的作用域是整个工程(项目)
总结7
1.main函数创建的变量也是局部变量。
2.main函数创建的变量只是范围更大了一些，能在main函数创建大括号里面通用，不能拿出来用。
3.在大括号里面创建的变量是局部变量，在大括号外面创建的变量是全局变量。
3.生命周期
指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的一个时间段，中间这个时间段，就是生命周期。
分析：局部变量生命周期是什么？
int maain
{
{
int a = 10; //-- 进作用域(进大括号) 创建，生命周期开始
int b = a + 1;
printf("%d\n", b); --结果是11
} //-- 出作用域(出大括号) 结束销毁，生命周期结束
printf("%d\n", b); --强行一起运行，编译器会报错，未声明的标识符
return 0;
}这就是局部变量的生命周期：进入作用域变量创建，生命周期开始，出作用域结束。
分析：全局变量生命周期是什么？
int c = 20;
void test()
{
printf("c = %d\n", c);//20，test函数能用
}
int c = 20;//如果把int c 放在这里使用，程序依次扫描程序会报错，说这里未声明
int main()
{
test();
printf("c = %d\n", c);//20,主函数能用
return 0;
}补充心得
1.只要程序还在运行这个全局变量都可以用，但是要合理的位置。
2.全局变量的生命周期是：是整个程序的生命周期。
总结8
1.不管使用全局变量和局部变量都要在合理的位置使用。
2.编译器依次扫描程序，有地方要声明的一定要先声明。
十.使用方法
1.static修饰局部变量
（1）
int a = 1;//这里加个全局全局变量，出函数之后不会销毁，2 3 4 5 6.
void test(void) 进入这个函数
{
int a = 1;//创建一个变量 a;大括号里面的是局部变量，进函数创建，出函数销毁
a++; //a++之后就变2
printf("%d \n", a);//打印 2 2 2 2 2
//打印完之后，出函数就销毁了，循环5次，每次都这样。
}
分析循环5次，每次函数调用//看tset函数分析
int main()
{
ing i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}
（2）
void test(void)
{
static int a = 1;//static修饰局部变量
a++;
printf("%d ", a);//2 3 4 5 6
}
int main()
{
int i = 0;
for (i = 0; i < 5; i++)
{
test();
}
return 0;
}1.当调用这个这个函数，进入函数的时候就创建变量，出函数之后不销毁了, 不会每次进函数就创建变量
(1) 分析:
内存分为3个核心区域
1.栈区：放 局部变量，形式参数，临时变量//栈区变量的特点：都是临时的，进入作用域创建，出作用域创建
2.堆区： 动态内存分配 malloc函数，calloc函数，realloc函数，free函数,这些函数申请空间都在堆区。特点手动申请，手动释放
3.静态区：放 全局变量，//静态变量 - 被static修饰的变量。放在静态区的变量，生命周期比较长和程序的生命周期一样
总结9：stctic修饰局部变量
1.本质上影响了变量的的存储类型。
2.一个局部变量是存在栈区的，但是被修饰后就存放在静态。
3.因为存储类型的变化，生命周期跟着变化，边长了。
4.创建时间也有变化：//全局变量，静态变量在编译器就把地址分配好了，更早，局部变量进入局部范围(大括号)才创建地址。
作用域 不变：只是生命周期变长了，下次能够接着用。
什么时候用stctic：当这里有个局部变量，你不想让它销毁了，还想能接着用上次遗留的值，有累计的效果。
2.stctic修饰全局变量，要用到多个文件
extern int qa;//声明外部符号，就是声明welt.c文件的全局变量
int main()
{
printf("%d", qa = );
return 0;
}#define _CRT_SECURE_NO_WARNINGS 1
//定义一个全局变量
int qa = 100;
总结10：static修饰全局变量
1.首先要知道全局变量是具有外边链接属性的，就是在其它源文件想使用，extern声明一下就可以使用。
2.全局变量被static修饰后，外部链接属性，变成内部链接属性，就是这个全局变量，只能在自己所在的.c文件中使用，其它文件看不到，相当于作用域变小了。
3.全局变量被修饰后变成了静态变量。
什么时候用stctic：你不想其它源文件使用，不想让别人看见 + stctic就可以。
3.static修饰函数
跟stctic全局变量几乎一模一样
extern int Add(int x， int y);//函数这里默认本身自带extern，这里也可以不写extern
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int v = Add(a, b);
printf("%d\n", v);
return 0;
}#define _CRT_SECURE_NO_WARNINGS 1
static int Add(int x, int y)
{
return x + y;
}1.理论上不能直接，不申明直接使用，但强行运行还是会出结果。
2.但还是得用extern申明一下这个函数。
3.如果用static去修饰定义Add函数，会报1个无法解析的外部命令的错误。就算声明了也不能再使用
总结11：static修饰函数
1.函数也是有具有外部链接属性，定义的函数在其它源文件里边，只要有合适的声明就能调用
2.但是被static修饰后，外部链接属性就变成了内部链接属性，只能在自己这个源文件使用，不能在其它源文件使用，即使声明了也不能使用。
什么时候用stctic：你写了个函数，你就想一个人使用，不想其它源文件使用。
总结6：
1.extern ：当一个符号不管是函数，还是全局变量，只要来自其它源文件，你要在这个源文件使用你就要用extern。
2.要区分static修饰全局变量和局部变量的特点。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
