C语言——函数

C语言——函数

函数的概念

• 函数：也叫子步伐。C语言中的函数就是一个完成某项特定使命的一小段代码。
  
• C语言函数分类：
  按照用户使用：库函数，自定义函数
  按照参数的形式：无参函数，有参函数
  按照是否有返回值的角度：有返回值函数，无返回值函数
  按照调用的角度：主调函数，被调函数
  

库函数

尺度库和头文件

• 库函数：C语言国际尺度ANSI C归档了一些常用的函数的尺度，就被叫做尺度库，差别编译器给出一系列函数的实现，这些函数叫库函数，比方：printf，scanf等。
  库函数相关头文件：https://zh.cppreference.com/w/c/header
  
• 库函数的使用：
  1.进入官网学习和查看，里面有例子
  2.举例：
  

1. #include<math.h>
2. int main
3. {
4.         double r=sqrt(16);
5.         printf("%lf\n",r);
6.         return 0;
7. }

复制代码

运行结果就为4.0
3.库函数文档的一般格式
（1）函数原型
（2）函数功能格式
（3）参数和返回类型阐明
（4）代码举例
（5）代码输出
（6）相关知识链接
自定义函数

• 函数的语法形式
  

1. ret_type_fun_name(形式参数)
2. {
3. }
4. //把函数想象成一个小工厂，工厂得输入原材料，才能生产产品，函数一样也需要输入一些值，经过函数内的计算得出结果
5. //ret_type表示函数计算结果的类型，有时候返回类型为void，表示什么都不返回。
6. //fun_name是为了方便使用函数，给起了一个名字
7. //函数的参数相当于工厂中送进去的原材料，函数的参数也可以是void，明确表示函数没有参数，如果有参数，要交代清楚参数的类型和名字，以及参数个数
8. //{}括起来的是函数体

复制代码

形参和实参

1. int Add(int x,int y)//形式参数，简称形参（即如果只定义不调用，这俩参数就只是形式上的参数）
2. {
3.         return x+y;//计算x+y后返回的是结果
4. }
5. int main()
6. {
7.         int a=0;
8.         int b=0;
9.         scanf("%d %d",&a,&b);
10.         int c=Add(a,b);//调用Add函数
11.         //真实传递给函数的参数，a，b是实际参数，简称实参
12.         printf("c=%d\n",c);
13.         return 0;
14. }

复制代码

• 形参的实例化：形式参数只有在函数被调用的过程中为了存放实参通报过来的值，才向内存申请空间，这个过程就是形参的实例化
  
• 形参和实参的关系：形参和实参各自有独立的空间；
  形参的修改不会影响实参；
  形参是实参的一份临时拷贝；
  实参和形参的名字可以相同，但依然是差别的空间。
  

return语句

• return后边可以是一个数值，也可以是一个表达式，假如是表达式则先执行表达式，在返回表达式的结果
  
• return后边也可以什么都没有，直接写return；这种写法得当函数返回类型是void的环境
  
• return语句执行后，函数就彻底返回，后边的代码不再执行
  
• return返回的值和函数返回类型不划一，系统就会主动将返回的值隐式转换为函数的返回类型，例：
  

1. int test()
2. {
3.         return 3.5;//这样写就牛头不对马尾
4. }
5. int main()
6. {
7.         int r=test();
8.         printf("%d\n",r);//此时打印结果就为3，3.5被强制转换成了int类型
9.         return 0;
10. }

复制代码

• 假如函数中存在if等分支语句，则要保证每种环境下都有return返回，否则会出现编译错误（必须思量全面，每一种环境都有返回值）
  
• 函数的返回类型假如不写，编译器会默认函数的返回类型是int；
  尽量有明确的返回类型，就直接写清晰，假如不需要返回就写void
  
• 函数写了返回类型，但是函数中没有使用return返回值，那么函数的返回值是未知的
  

数组做函数参数

一维数组的传参：

1. //将数组内容全变成-1并打印
2. #include<stdio.h>
3. void set_arr(int arr[],int sz)
4. {
5.         int i=0;
6.         for(i=0;i<sz;i++)
7.         {
8.                 arr[i]=-1;
9.         }
10. }
11. //写一个函数，打印arr数组的所有内容
12. void print_arr(int arr[],int sz)
13. {       
14.         int i=0;
15.         for(i=0;i<sz;i++)
16.         {
17.                 printf("%d",arr[i]);
18.         }
19.         printf("\n");
20. }
21. int main()
22. {
23.         int arr[]={1,2,3,4,5,6,7,8,9,10};
24.         int sz=sizeof(arr)/sizeof(arr[0]);
25.         set_arr(arr,sz);//函数的调用
26.         print_arr(arr,sz);//数组传参的时候，实参应该写数组名
27.         return 0;
28. }

复制代码

二维数组的传参：

1. void print_arr2(int arr[][5],int r,int c)//行可省，列不可省
2. {
3.         int i=0;
4.         for(i=0;i<r;i++)
5.         {
6.                 int j=0;
7.                 for(j=0;j<c;j++)
8.                 {
9.                 printf("%d ",arr[i][j]);
10.                 }
11.                 printf("\n");       
12.         }
13. }
14. int main()
15. {
16.         int arr[3][5]={{1,2,3},{2,3,4,5},{3,4,5,6,7}};
17.         print_arr2(arr,3,5);
18.         return 0;
19. }

复制代码

数组传参时需要注意：

• 函数的形参要和函数的实参个数匹配
  
• 函数的实参是数组，形参也可以是写成数组形式的
  
• 形参假如是一维数组，数组巨细可以省略不写
  
• 形参假如是二维数组，行可以省略，但是列不能省略
  
• 数组传参，形参是不会创建新的数组的
  
• 形参操纵的数组和实参的数组是同一个数组
  

嵌套调用和链式访问

嵌套调用：函数之间的互相调用，例：

1. //使用函数的方式实现某年某月有多少天
2. #include<stdio.h>
3. #include<stdbool.h>
4. bool is_leap_year(int y)
5. {
6.         if(((y%4==0)&&(y%100!=0))||(y%400==0))
7.                 return true;
8.         else
9.                 return false;
10. }
11. int get_days_of_month(int y,int m)
12. {
13.         int days[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
14.         //来一个判断闰年的函数功能
15.         int d=days[m];
16.         if(is_leap_year(y)&&m==2)//嵌套调用
17.         {
18.                 d+=1;
19.         }
20.         return d;
21. }
23. int main()
24. {
25.         int year=0;
26.         int month=0;
27.         scanf("%d %d",&year,&month);
28.         int day=get_days_of_month(year,month);
29.         printf("%d\n",day);
30.         return 0;
31. }

复制代码

链式访问：链式访问就是将一个函数的返回值作为另一个函数的参数，像链条一样将函数穿起来就是函数的链式访问，例：

1. int main()
2. {
3.         printf("%zd\n",strlen("abcdef"));//链式访问，将函数的参数作为返回值
4. }

复制代码

1. int main()
2. {
3.         printf("%d",printf("%d",printf("%d",43)));//链式访问
4. //printf参数的返回值是打印在屏幕上字符的个数
5. }

复制代码

打印结果是4321
函数的声明和定义

单个文件

函数的声明就是告诉编译器 ，有一个函数：名字是什么 ，参数是什么，返回类型是什么

1. int is_leap_year(int y);//函数的声明
2. //int is_leap_year(int);//函数的声明中形式参数的名字可以省略
3. int main()
4. {
5.         int year=0;
6.         scanf("%d",&year);
7.         if(is_leap_year(year))//函数的调用
8.                 printf("闰年\n");
9.         else
10.                 printf("非闰年\n");
11.         return 0;
12. }
13. //函数的定义，如果把函数的定义放在最下面函数调用的后面会有问题，除非你先声明一下
14. int is_leap_year(int y)
15.         {
16.                 if((y%4==0)&&(y%100!=0)||(y%400==0))
17.                         return 1;
18.                 else
19.                         return 0;
20.         }

复制代码

多个文件

• 头文件中放声明函数
  
  
  
  
• 函数定义
  
  
  
  
• 包含头文件，然后调用函数
  
  
  
  ——这是可以运行的
  
  
  
  假如不写头文件也是可以的，只需要在int main()前加入
  

1. extern int Add(int x,int y);//相当于声明

复制代码

extern这个关键字是用来声明外部符号的
以上写法，函数的定义和声明是分离的，如许写方便模块化的编程，也方便协作
static和extern(都是C语言中的关键字)

• 作用域：一段步伐代码中所用到的名字并不总是有效的，而限定这个名字的可用性的代码范围就是这个名字的作用域
  1.局部变量的作用域是变量地点的局部范围；
  2.全局变量的作用域是整个项目。
  
• 生命周期：是指变量的创建（申请内存）到变量的销毁 （收回内存）之间的一个时间段
  1.局部变量的生命周期：进入作用域变量创建，生命周期开始，出作用域生命周期结束；
  2.全局变量的生命周期：整个步伐的生命周期
  
• static：
  1.修饰局部变量；
  
  
  

运行结果为23456，若没有static修饰，运行结果为22222
static修饰了局部变量n，使其的生命周期变长了（本质是改变了变量的存储类型，本来是一个局部变量存储在内存的栈区，但被static修饰后到了静态区。存储在静态区的变量和全局变量是一样的，生命周期就和步伐的生命周期一样了，只有步伐结束 ，变量才销毁，内存才接纳。但是作用域不变）
2.修饰全局变量；
static修饰全局变量后（外部链接属性变成了内部链接属性），使得这个全局变量只能在本源文件中使用，即使声明白，也不能在其他源文件中使用
3.修饰函数
函数默认是有外部链接属性的，用static修饰后，函数的外部链接属性变成内部连接属性，是的函数只能在自己的.c文件中使用，其他.c文件不能使用

• extern:用来声明外部符号（外部符号可以是全局变量，函数等）
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。