6.函数

1.函数基本概念

• 避免重复性代码
• 程序模块化

2.函数的三种形式：

1.函数的定义

• 函数写在main的外边

函数类型 函数名（数据类型1 形参1，数据类型2，形参2，........）

{

        语句块；

          return 返回值；

}

函数类型：函数运行结果的类型，省略不写默认为int类型，可以写成void表示没有运行结果。

函数名：与变量名要求保持一致。

形参：形式参数，展示对数据的操作方法

返回值：函数的结果如果与函数类型不一致，需要强制将返回值类型改成函数类型。

2.函数的调用

函数名（实参1，实参2，....）;

注意：

• 实参将把自己的值给到形参

练习：写一个比较大小的函数，调用函数。

  1 #include<stdio.h>                                                                                                                   
  2 int fun(int x,int y)
  3 {
  4     if(x>y)
  5     {
  6         printf("%d>%d",x,y);
  7     }
  8     else
  9     {
 10         printf("%d<%d",x,y);
 11     }
 12     return 0;
 13 }
 14 int main(void)
 15 {
 16     int a = 0;
 17     int b = 0;
 18     scanf("%d %d",&a,&b);
 19     fun (a,b);
 20     return 0;
 21 }

练习：写出加减乘除的函数，进行调用。

  1#include<stdio.h>                                                                                                                   
  2 int add(int x,int y)
  3 {
  4     return x+y;
  5 
  6 }
  7 int sub(int x,int y)
  8 {
  9 
 10     return x-y;
 11 
 12 }
 13 int mul(int x,int y)
 14 {
 15 
 16     return x*y;
 17 
 18 }
 19 int div(int x,int y)
 20 {
 21 
 22     return x/y;
 23 
 24 }
 25 int main(void)
 26         {
 27         int a = 0;
 28         int b = 0;
 29         scanf("%d",&a);
 30         scanf("%d",&b);  
 31         add(a,b);
 32         sub(a,b);
 33         mul(a,b);
 34         div(a,b);
 35         printf("add=%d\n",a+b);
 36         printf("sub=%d\n",a-b);
 37         printf("mul=%d\n",a*b);
 38         printf("div=%d\n",a/b);
 39         return 0;
 40         }        

3.函数的声明

如果被调函数在主调函数的下方定义，需要对被调函数声明。

  1 #include<stdio.h>
  2 int sum(int x,int y);//函数声明
  3 
  4 int main(void)
  5 {
  6     int a = 0;
  7     int b = 0;
  8 
  9     scanf("%d",&a);
 10     scanf("%d",&b);
 11     sum(a,b);
 12     printf("add = %d",a+b);                                                                                                         
 13 
 14         return 0;
 15 }
 16 int sum(int x,int y)
 17 {
 18     return x+y;
 19 }
       

3.变量的作用域和生存周期

1.作用域：

• 一个变量能使用的范围。
• 局部变量：变量的作用域在局部范围内，（只能在最近的大括号内使用）出了作用域没法使用变量。
• 全局变量：变量的作用域在全局范围内，整个代码中任意范围都可使用。
• 全局变量可以和局部变量重名，局部范围内，局部变量会将全部变量隐藏。
• 全局变量尽量不要和局部变量命名重合，且使用的全局变量用的越多风险越大。

2.生存周期：

• 变量从创造出来到回收的整个过程
• 不同的变量生存周期是不同的

存储类型 数据类型 变量名；

存储类型：

1.auto

2.register

3.extern

4.static

1.auto 自动型变量，局部变量（默认存储类型）

• 将变量存放在栈区
• 未经初始化值为随机值
• 程序运行到变量定义时，为其开辟空间。
• 程序运行超过变量作用域回收空间。

2.register寄存器变量

• 将变量存放在CPU内部的寄存器中，寄存器存满则存放在栈区等价于auto类型。

3.extern 声明外部变量

• 引用一个外部定义的变量，需要在当前文件中声明该变量为外部存储类型。
• 只是声明一个变量，不是定义变量，不会为他开辟空间，一般局部变量不会被外部调用，大部分是全局变量，全局变量存于数据区。

4.static静态变量

• 延长变量生存周期，在编译时分配空间，代码运行结束回收空间。
• 限定变量或者函数只能在本文件中使用。
• 防止多文件全局变量重名。
• 存于数据区。

C语言内存分布：

• 

2.函数传参

1.值传递：

• 函数内部想要操作函数体外部变量值的时候需要传参
• 值传递只能使用外部变量的值，无法改变外部变量值
• 函数调用，实参将值传给形参，形参是实参的副本，形参改变不会影响实参。

不传参示例：

#include<stdio.h>
  void   fun(void)
{
    return;
}
int main(void)
{
    fun();

    return 0;
}

2.全局变量传参。

  1 #include<stdio.h>
  2                                                     
  3 int a = 100;
  4 int b = 200;
  5 void swap(void)
  6 {
  7     int tmp = 0;
  8     tmp = a;
  9     a = b;
 10     b = tmp;
 11     return ;
 12 }
 13 int main(void)
 14 {
 15     swap();
 16     printf("a = %d,b = %d\n",a,b);
 17     return 0;
 18 }
~     

3.数组数据传递：

1.形式一：

int a[5] = {1,2,3,4,5};

int fun (int array [5])

2.形式二：

int a [5] = {1,2,3,4,5};

int fun (int array[ ],intlen);

#include<stdio.h>                                      
  2 int outputarray1 (int array[5])
  3 {
  4     int i = 0;
  5     for (i= 0;i < 5;i++)
  6     {
  7         printf("array[%d] = %d\n",i,array[i]);
  8 
  9     }
 10 
 11     return 0;
 12 }
 13 int outputarray2(int array[],int len)
 14 {
 15     int i = 0;
 16     for (i = 0;i<len; i++)
 17     {
 18         printf("array[%d] = %d\n",i,array[i]);
 19 
 20     }
 21     return 0;
 22 }
 23 double avenum(int array[],int len)
 24 {
 25     int i = 0;
 26     double  sum = 0;
 27     for (i = 0; i<len;i++)
 28     {
 29         sum +=array[i];
 30 printf("平均值：%.2f",sum/len);
 31     }
 32     return sum/len;
 33 }
 34 
 35 int main(void)
 36 {
 37     int a[5] = {1,2,3,4,5};
 38     outputarray1 (a);
 39     outputarray2 (a,5);
 40     avenum(a,5);
 41     return 0;
 42 }                           

  1 #include<stdio.h>                                      
  2 void inputarray(int array[],int len)
  3 {
  4 
  5     int i = 0;
  6     for(i = 0;i<len;i++)
  7 
  8     {
  9         scanf("%d\n",&array[i]);
 10     }
 11     return;
 12 }
 13 void  outputarray (int array[],int len)
 14 {
 15     int i = 0;
 16     for (i= 0;i < len;i++)
 17     {
 18         printf("array[%d] = %d\n",i,array[i]);
 19 
 20     }  
 21     return ;
 22 }
 23 void bubblesortarray(int array[],int len)
 24 {
 25     int i = 0;
 26     int j = 0;
 27     int tmp = 0;
 28  for (j = len-1;j>0;j--)
 29     {
 30         for(i= 0;i<j;i++)
 31 
 32         {
 33             if(array[i]>array[i+1])
 34             {
 35                 tmp = array[i];
 36                 array[i] = array[i+1];
 37                 array[i+1] = tmp;
 38             }
 39 
 40         }
 41 
 42     }
 43 
 44     return;
 45 }
 46 int main(void)
 47 {
 48     int a[5]= {0};
 49     inputarray(a,5);                                   
 50     bubblesortarray(a,5);
 51     outputarray(a,5);
 52     return 0;
 53 }

:wq

4.字符型数组和字符串的传递：

char  str[32] = {"hello world"};

int fun(char str[ ]);

  1 #include <stdio.h>
  2 int MyStrlen(char pstr[])
  3 
  4 {
  5     int i = 0;
  6     while(pstr[i]!='\0')
  7     {
  8     i++;
  9     }                                                  
 10 return i;
 11 
 12 }
 13 int main(void)
 14 {
 15     char str[32] = {0};
 16     int len = 0;
 17     gets(str);
 18     len = MyStrlen(str);
 19     printf("长度：%d\n",len);
 20 
 21 return 0;
 22 }

练习：从终端接收一个字符串，封装函数统计该字符串中空格的个数

  1 #include <stdio.h>
  2 int num(char pstr[])
  3 
  4 {                                                   
  5     int i = 0;
  6     int t = 0;
  7     while(pstr[i]!='\0')
  8     {
  9         if(pstr[i]==' ')
 10         {
 11         t++;
 12         }
 13     i++;
 14     }
 15 return t;
 16 
 17 }
 18 int main(void)
 19 {
 20     char str[32] = {0};
 21     int n = 0;
 22     gets(str);
 23     n = num(str);
 24     printf(" 空格个数：%d\n",n);
 25 
 26 return 0;
 27 }

练习:封装一个函数实现strcpy的功能

  1 #include<stdio.h>
  2 #include<string.h>
  3 char  MyStrcopy(char pstr1[],char pstr2[])
  4 {
  5     int i = 0;
  6     int len = 0;
  7         len = strlen(pstr1);
  8     for(i = 0;i <len;i++)
  9     {
 10         pstr2[i]=pstr1[i];
 11 
 12     }
 13     return;
 14 }
 15 
 16 int main (void)
 17 {
 18     char str1[32] = {0};
 19     char str2[32] = {0};
 20     gets(str1);
 21     MyStrcopy(str1,str2);
 22     printf("str2 = %s\n",str2);                     
 23     return 0;
 24 }

3.函数嵌套调用

• 主调函数调用被调函数，被调函数运行结束后回到主调函数继续向下进行。

  1 #include <stdio.h>
  2 int fun (int n)
  3 {
  4     if (n==1)
  5     {
  6         return 1;
  7 
  8     }
  9 return n*fun(n-1);
 10 }
 11 int main(void)
 12 {
 13     int num = 0;
 14     int ret  = 0;
 15     scanf("%d",&num);
 16     ret = fun(num);
 17     printf("ret = %d\n",ret);
 18 
 19     return 0;                                       
 20 }

4.函数递归调用

1.函数体在定义时调用函数本身，这样的函数称为递归函数

注意：

• 递归函数一定要有结束条件
• 避免深层次递归调用

练习：通过递归实现函数。传入n值，返回斐波那契数列第n项的值。

  1 #include <stdio.h>
  2 
  3 int fun (int n)
  4 {
  5     if (n == 0||n ==1)
  6     {
  7         return 1;
  8     }
  9     return fun(n-1) + fun(n-2);
 10 
 11 }
 12 
 13 
 14 int main(void)
 15 {
 16     int n = 0;                                      
 17     int ret = 0;
 18 
 19     scanf("%d",&n);
 20 
 21     ret = fun(n);
 22     printf("ret = %d\n",ret);
 23 
 24     return 0;
 25 
 26 }