C语言--函数

1、function(功能)：完成某个功能的指令序列的封装。
2、函数特点：
  相同功能的代码块
  重复利用
  模块化思想
3、如何让去设计一个函数？
  函数是用来实现一个功能或任务的
  例子：
    求两个整数之和
  （1）明确函数功能
    求和：定义一个函数名---sum
  （2）需要哪些输入资源
    int a,int b
  （3）完成目标后输出结果是什么？（返回值）
    确定函数返回值的类型
    int
    有时候函数的输入结果程序员可以自定义：
  （4） 算法实现
    int sum(int a,int b)
    {
      return a+b;
    }
4、语法形式
  int--->函数返回值类型
  sum-->函数名
  （int a,int b）-->输入参数列表
  {  }-->函数体

  （1）函数返回值类型：
    “单值类型”：结果用一个寄存器或两个寄存器可以保存的值
      int / long
      C=>汇编
    汇编语言在实现函数的返回值时，约定把函数的返回值，放在寄存器R0或者R0、R1中。
    void： 表示此函数没有返回值（void不能省略）
  
  （2）输入参数列表：int a,int b
    类型1 参数名1，类型2 参数名2，。。。，类型n 参数名n
    参数类型可以相同，但是参数名一定不能相同
    void ： 表示该参数没有参数（void可以省略）

  （3）return ： 返回的意思
    return只能是出现在函数内部，用来表示函数结束。
    return ；=>函数结束，不带任何返回值
    return 表达式；=>函数结束，带一个返回值，“表达式的值”
      函数的返回值类型，就是return语句后面表达式的值的类型
5、函数的调用
  调用一个已经写好的函数去执行函数体内封装的指令序列。
  （1） 如何去调用一个函数？
    a 需要指定哪个任务/函数，指定任务名/函数名
    b 完成该任务实际上需要的参数（实际参数）
    c语言：
      函数名（实参列表）
      例子：
      int sum(int a,int b)
      {
        return a+b;
      }
      sum(3,4);   
    形式参数：定义函数时的参数（“形参”）
    实际参数：调用这个函数的时候，传入的参数（“实参”）
      实参：就是一个表达式
        指定实参时，不需要指定其类型
        调用函数时，需要指定“实参”，实参要与形参相对应；
          实参与形参类型相对应
          实参与形参个数相对应
      "值传递"：形参=实参值（把实参的值传递给相对应的形参）
      例子：
        int x=4,y=3;
        sum(x,y);
        sum(x+5,y+6);
        sum(3+5,5*7);
        sum(1.0*x,y);//ERROR
        sum(int x,int y);//ERROR

  （2）函数调用表达式
    函数名（实参列表）
  （3） 函数调用过程
    sum(3,4)
    函数调用过程时如何发生的呢？
    a、把实参的值赋值给相对应的形参
    b、跳转到指定函数中去执行
      直到遇到return，或者 函数语句执行完毕
      return后面表达式的值，将作为整个函数调用表达式的值进行返回
    
  （4）函数声明
    告诉编译器这个函数的名字，告诉编译器，这个标识符（函数名）是一个函数，在后面某个位置会定义的。

6、数组作为函数的参数
  数组元素类型 数组名[元素个数]
    数组元素类型  数组名[ ]  ，int 元素个数
  传递实参（调用）：
    函数名（数组名，元素个数）
  例子：
    （1）一维数组
      int a[10];
      @b参数接收一个数组元素为int类型的数组 的数组名
      @n接收数组元素的个数

      ==>     返回值类型 func1(int b[],int n)
                 {    }   
      调用：
        func1(a,10)   


    （2）二维数组
      int a[3][4];//
      ==>  int [4] a[3]
      @b参数接收一个数组元素为int类型的数组 的数组名
      @n接收数组元素的个数
      ==>  //返回值类型 func2(int [4]b[ ],int n )
        返回值类型 func2(int b[ ][4],int n )
        {   }
      矩阵角度：
        二维数组元素类型  数组名[][列数]，int 行号
      调用:
        func2(a,3);
 7、关于函数的声明问题
  告诉编译器，这个标识符是个什么东西。
  一般来说，在源文件的前面，要进行标识符的声明。
  变量声明：
    1.c
      int a=250;
    2.c//想要在2.c中使用1.c中的同一个a

    外部声明：extern int a;
    gcc 1.c 2.c

    函数声明
    1.c
    void func(void)
    {
      int a=250;
      printf("%d",a);
    }

    2.c
    extern void func(void);
    int main()
    {
      func();
    }
    约定：声明语句一般在使用的前面。

​​写一个函数，用来求三个数中较大的那个​​

//写一个函数，用来求三个数中较大的那个
/*
  Get_Max : 求三个整数中较大的那一个
  @a : 整数之一
  @b : 整数之一
  @c : 整数之一
  返回值：返回较大的那一个整数值=>int
*/
#include<stdio.h>
int Get_Max(int a,int b,int c)
{
  if(a>b&&a>c)
  {
    return a;
  }
  else if(b>a&&b>c)
  {
    return b;
  }
  else if(c>a&&c>b)
  {
    return c;
  }
}

int main()
{
  int a,b,c,d;
  scanf("%d%d%d",&a,&b,&c);
  d=Get_Max(a,b,c);
  printf("%d\n",d);
}

​​写一个函数，用来求n!​​

#include<stdio.h>
int Get_JieC(int n);

//写一个函数，用来求n!
/*
  Get_JieC : 求n!
  @n : 整数之一
  返回值：返回整数值=>int
*/

int Get_JieC(int n)
{
  int i=1, s=1;
  while(i<=n)
  {
    s=s*i;
    i++;
  }
  return s;
}
int main()
{
  int n,d;
  scanf("%d",&n);
  d=Get_JieC(n);
  printf("%d!=%d\n",n,d);
}

​​写一个函数，完成对一个一维数组从键盘输入的问题​​

#include<stdio.h>
#define N 5
//写一个函数，完成对一个一维数组从键盘输入的问题。
/*
  Func_Sr: 输入一个一维数组
  @a : 数组名
  @b : 数组元素个数
  返回值：无返回值->void
*/
void Func_Sr(int a[],int b)
{
  for(int i=0;i<b;i++)
  {
    scanf("%d",&a[i]);
  }
}
int main()
{
  int a[N];
  Func_Sr(a,N);
  for(int i=0;i<N;i++)
  {
    printf("%d ",a[i]);
  }
}

​​写一个函数，求一个二维数组中的最大值。​​

#include<stdio.h>
#define N 4
#define M 3
//写一个函数，求一个二维数组中的最大值。
/*
  Get_Max: 求一个二维数组中的最大值
  @a : 数组名
  @b : 数组元素个数
  返回值：返回一个整数值=>int
*/
int Get_Max(int a[][N],int b) 
{
  int max=a[0][0];
  for(int i=0;i<b;i++)
  {
    for(int j=0;j<N;j++)
    {
      if(a[i][j]>max)
      {
        max=a[i][j];
      }
    }
  }
  return max;
}
int main()
{
  int a[M][N];
  int max;
  for(int i=0;i<M;i++)
  {
    for(int j=0;j<N;j++)
    {
      scanf("%d",&a[i][j]);
    }
  }
  max=Get_Max(a,M);
  printf("max=%d\n",max);
}

​​判断一个一维数组是否有序，是升序还是降序​​

#include<stdio.h>
#define N 5
//判断一个一维数组是否有序，是升序还是降序
/*
  Pand_Youx:判断一个一维数组是否有序，是升序还是降序
  @a : 数组名
  @n : 数组元素个数
  返回值：返回一个整数值   有序-1
*/
/*
  判断有多少个‘ < ’‘ > ’符号
*/
int Pand_Youx(int a[],int n)
{
  int count=0,c=0;
  for(int i=0;i<n-1;i++)
  {
    if(a[i+1]>a[i])
    {
      count++;
    }
    if(a[i+1]<a[i])
    {
      c++;
    }

  }
  if(count == n-1)
  {
    return 1;
  }
  else if(c==n-1)
  {
    return -1;
  }
  else 
    return 0;
  
}
int main()
{
  int a[N];
  int x;
  for(int i=0;i<N;i++)
  {
    scanf("%d",&a[i]);
  }
  x=Pand_Youx(a,N);
  if(x==1)
  {
    printf("递增\n");
  }
  else if(x==-1)
  {
    printf("递减\n");
  }
  else
    printf("无序\n");
}