首页 > 其他分享 >C语言学习记录(七)

C语言学习记录(七)

时间:2023-03-27 13:34:24浏览次数:45  
标签:调用 return 函数 记录 int max C语言 学习 printf

C语言学习记录(七)

一、知识要点(函数)

一、函数的作用

  • 在一个应用程序中的若干个功能相互独立,可单独操作的程序单元叫做模块。在C语言中用函数实现模块的功能,将这些模块构成完整的程序来完成问题的解决。

  • 在C语言中,除了主函数,其他的函数称之为子函数。一个C语言程序由一个主函数和若干个子函数构成,主函数可以调用子函数,子函数之间也可以互相调用(包括自己),但是主函数不能被调用

  • 从使用角度看,C函数包括两种:库函数和自定义函数。库函数是编译系统提供的,而自定义函数需要自己构造。

  • 从函数的形式看,C函数有两类:无参函数和有参函数。无参函数被调用时,主函数不用向子函数传递数据,而有参函数则需要。

    #include <stdio.h>              
    #include <string.h>
    
    // 定义无参函数myprint,输出18个星号
    void myprint()
    {
        int i = 0;
    
        for (i = 1; i <= 18; i++)
            printf("*");
            
        printf("\n");
    }
    
    // 定义有参函数myprint_n,输出n个星号
    void myprint_n(int n)
    {
        int i = 0;
    
        for (i = 1; i <= n; i++)
            printf("*")
    
        printf("\n");
    }
    
    // 主函数
    int main()
    {
        // 调用函数myprint,输出18个星号
        myprint();
    
        // 调用函数myprint_n,输出6个星号
        myprint_n(6);
    
        // 调用函数myprint_n,输出12个星号
        myprint_n(12);
    
        // 调用函数myprint,输出18个星号
        myprint();
    
        return 0;
    }
    
    #include <stdio.h>              
    #include <string.h>
    
    // 自定义函数mypow,实现计算x的y次方
    double mypow(double x, int y)
    {
        int i;
        double z = 1.0;
    
        // 循环计算x的y次方
        for (i = 1; i <= y; i++)
            z = z * x;
    
        return z;
    }
    
    // 主函数
    int main()
    {
        double x, z;
        int y;
    
        // 提示用户输入x和y
        printf("输入x,y:");
        scanf("%lf%d", &x, &y);
    
        // 调用mypow函数,计算x的y次方
        z = mypow(x, y);
    
        // 输出结果
        printf("%.2lf, %d, %.2lf", x, y, z);
    
        return 0;
    }
    
  • 总结

    • 一个C语言程序中,只能有一个main函数,并且程序的执行都是从main函数开始,然后调用其他函数,最后回到main函数直到结束。
    • 在C语言中函数之间是相互独立的,不允许函数嵌套定义。

二、函数定义和函数调用

1、函数定义

  • 函数定义的一般形式

    • 函数定义的一般形式如下:
      [类型名] 函数名([形式参数表])
      {
      声明部分;
      执行部分;
      }

    • 第一行称为函数首部,花括号内的部分称为函数体

    • 类型名指定函数的类型,若返回值为int型,则可省略int。如果函数无返回值,则为void型
      形式参数表指定函数参数的名字和类型。有参数的形参表可以由多个形参,而且必须单独定义,各形参直接用逗号隔开。无参函数无形参表,但不能省略空括号。

    • #include <stdio.h>
      
      // 自定义函数my_max,返回三个整数中的最大值
      int my_max(int a, int b, int c)
      {
          int max;
      
          // 比较a和b的大小,取较大值
          if (a > b)
              max = a;
          else
              max = b;
      
          // 再比较之前的较大值和c的大小,取最大值
          if (max < c)
              max = c;
      
          return max;
      }
      
      // 主函数
      int main()
      {
          int x, y, z, m;
      
          // 提示用户输入三个整数
          printf("输入三个整数:");
          scanf("%d %d %d", &x, &y, &z);
      
          // 调用my_max函数,求出最大值
          m = my_max(x, y, z);
      
          // 输出最大值到控制台
          printf("最大值为%d", m);
      
          return 0;
      }
      
  • 空函数的定义形式
    函数体中没有任何内容的函数称为空函数,空函数的定义形式如下:
    [类型名] 函数名()
    {}
    程序设计时常在准备扩充功能的地方写上一个空函数,用空函数占个位置。

2、函数调用

  • 函数调用的一般形式

    • 形式为:
      函数名([实际参数表])

    • 函数名为被调用的函数的名字,在一个函数中允许多次调用其他函数

    • 如果被调用的是有参函数,括号内的实参之间要用括号隔开,并且要与形参形式一致。

    • 如果调用的是无参函数,则实参表为空。

    • 执行过程:先将实参的值赋给形参,然后执行被调函数的函数体语句,执行完之后将结果返回到主调函数。

    • #include <stdio.h>
      #include <math.h>
      
      // 自定义函数my_fac,用于计算n的阶乘
      double my_fac(int n)
      {
          int i;
          double p = 1;
      
          // 计算n的阶乘
          for (i = 1; i <= n; i++)
          {
              p *= i;
          }
      
          return p;
      }
      
      // 主函数
      int main()
      {
          int n;
          double sq, m;
      
          // 提示用户输入一个整数n
          printf("请输入一个整数:");
          scanf("%d", &n);
      
          // 调用内置函数sqrt求出n的平方根
          sq = sqrt(n);
      
          // 调用my_fac函数计算n的阶乘
          m = my_fac(n);
      
          // 输出n的平方根和阶乘到控制台
          printf("%.2lf %.2lf", sq, m);
      
          return 0;
      }
      
  • 函数调用方式

    • 函数语句方式
      这种调用方式是把函数用作一个独立的语句。如例题中:
      my_print();
      my_print_n(6);
      这种不要求被调函数返回值,只要求被调函数完成一系列操作。
    • 函数表达式方式
      这种调用方式是把函数调用用在表达式的组成部分中,要求被调函数返回一个确定的值来参加表达式运算。如:
      z = 2 * my_fac(n);
    • 函数参数方式
      这种调用方式是将一个函数作为一个函数的实参。例如:
      m = min(a, min(b, c));,又如:
      printf(" %f", min(a, b));
      这种方式实质上也是一种函数表达式方式的调用。
  • 形式参数与实际参数

    • 在函数定义时形式参数表中的变量时形式参数,简称形参;在函数调用中的实际参数表中的参数称为实际参数,简称实参

    • #include <stdio.h>
      #include <math.h>
      
      // 自定义函数my_max,返回两个整数中的最大值
      int my_max(int x, int y)
      {
          int max;
      
          // 使用条件运算符(三目运算符)比较x和y的大小,取最大值
          max = x > y ? x : y;
      
          return max;
      }
      
      // 主函数
      int main()
      {
          int a, b, max;
      
          // 提示用户输入两个整数
          printf("输入两个整数:");
          scanf("%d %d", &a, &b);
      
          // 调用my_max函数,求出两个整数中的最大值
          max = my_max(a, b);
      
          // 输出最大值到控制台
          printf("max = %d", max);
      
          return 0;
      }
      
    • 关于形参和实参的说明

      • 在函数未被调用时,形参不占用内存中储存单元。而当调用时,才分配储存单元(与实参的储存单元类型不同)。函数调用结束后,形参单元被系统释放,实参的数值不变,这就是C语言所采用的单项的值传递方式。
      • 实参可以是常量、变量或表达式。但是他们在调用前必须有确定的值。
  • 函数的返回值

    • return语句的语法格式
      return [(表达式)]

      • return语句的两个功能

        • 如果函数有返回值,则计算return后面的表达式的值,并把值传回主函数。
        • 终止被调函数的执行,使流程返回主函数。
      • return语句的使用形式

        • return后面的表达式可以不用圆括号圈起来。

        • 一个函数若没有返回值,则return后面可以不跟表达式,只是用来使流程转向主函数。

        • 若不需要被调函数的返回值,则可以不写return语句。

        • 一个函数可以有多个return语句,如:

          #include <stdio.h>
          
          int sign(double x)
          {
              if (x > 0)
                  return 1;
              else if (x == 0)
                  return 0;
              else    
                  return -1;
          }
          
          int main()
          {
              double x;
          
              printf("输入一个整数:");
              scanf("%lf", &x);
          
              printf("%d", sign(x));
          
              return 0;
          }
          
    • 函数的返回值类型
      函数的类型决定了函数返回值的类型。

      • 在定义函数时,应指定函数的类型,从而确定返回值类型。
      • 若return语句的类型与被调函数返回值类型不一致,系统则会强行改为返回值类型。
      • 对于无返回值类型函数,函数的类型名应该说明为void型,表示无类型。
  • 被调函数声明与函数原型

    • 当采用自顶向下的格式(先写main函数)编写程序时,需要先声明要使用的子函数。

    • 函数说明有两种格式:
      类型名 函数名(参数类型1 参数名1, 参数类型2 参数名2,..., 参数类型n 参数名n);
      类型名 函数名(参数类型1, 参数类型2,..., 参数类型n)

    • 若被调函数在主调函数之前定义,则可不必对被调函数加以声明。

    • 若被调函数在主调函数之后定义,则需要在主调函数内对被调函数作声明。

      #include <stdio.h>
      
      double sub(double x, double y); // 声明函数sub
      
      int main() 
      { 
          double a, b, c;
      
      	scanf("%lf%lf", &a, &b);     // 输入两个双精度浮点数
      
      	c = sub(a, b);               // 调用函数sub,将其返回值赋给变量c
      
      	printf("%lf", c);            // 输出变量c的值
      
      	return 0;
      }
      
      double sub(double x, double y) // 定义函数sub 
      { 
          double z;
      
      	z = x - y;
      
      	return z;                    // 返回值为z
      }
      
    • 如果在文件的开头已对本程序中要调用的所有函数进行了声明,那么之后就不用再声明了。

三、函数调用中的参数传递

1、简单变量作函数参数

  • 当形参是简单变量时,实参和形参之间采用数值传递方式。形参和实参的储存单元类型不同,所以形参的改变不影响实参单元,因此只能由实参向形参单向传递

  • #include <stdio.h>
    
    	// 函数声明:定义函数mult,其返回值为int类型,参数为n。 
    int mult(int n);
    
    int main() 
    {	 // 定义并初始化变量num和res int num = 668; int res = mult(num);
    
    	// 输出变量num和res的值
    	printf("num = %d\n", num);
    	printf("res = %d\n", res);
    
    	return 0;
    }
    
    	// 函数定义:定义函数mult,其返回值为int类型,参数为n。 
    int mult(int n) 
    { 	// 将参数n乘以
        10 n *= 10;
    
    	// 返回乘以10后的结果
    	return n;
    }
    

2、指针变量作函数参数

  • 当形参为指针变量时,对应实参一定是一个指针,其类型相同,值为地址,所以采用地址传递方式。

  • 由于形参和实参指向同一个储存单元,被调函数对形参的改变能实现实参所指的单元的改变,所以他们的数据是双向传递的,但是地址传递是单向的

  • #include <stdio.h>
    void swap(int *p1, int *p2);     //指针函数声明
    
    int main()  //主函数,把两个整数按降序排列
    {
        int a, b;
        int *p1, *p2;
    
        printf("请输入两个整数a, b:");
        scanf("%d%d", &a, &b);
    
        p1 = &a;
        p2 = &b;
    
        if (a < b)
            swap(p1, p2);
    
        printf("max = %d, min = %d\n", a, b);
    
        return 0;
    }
    
    void swap(int *p1, int *p2)     //定义一个函数,可将两个指针里的值交换
    {
        int temp;
    
        temp = *p1;
        *p1 = *p2;
        *p2 = temp;
    }
    
  • #include <stdio.h>
    void swap(int *p1, int *p2);        //交换指针地址函数声明
    
    int main()          //主函数
    {
        int a, b;
        int *p1, *p2;
    
        printf("输入两个整数:");
        scanf("%d%d", &a, &b);
    
        p1 = &a;        //赋指针变量a,b地址
        p2 = &b;
    
        if (a < b)      //判断a,b的大小
            swap(p1, p2);
        
        printf("max = %d, min = %d", a, b);
    
        return 0;
    }
    
    void swap(int *p1, int *p2)     //子函数调换指针地址
    {
        int *temp;
    
        temp = p1;
        p1 = p2;
        p2 = temp;
    }
    
    //运行结果为:max = 1, min = 2
    //此程序说明了地址传递是单向的。。。。
    

3、数组作参数函数

  • 数组元素做函数参数

    • 同简单变量做函数参数一样,单个数组元素做参数也是单向的数值传递方式。

    • #include <stdio.h>
      int large(int x, int y);        //声明子函数
      
      int main()
      {
          int i, n = 0, m = 0, k = 0;
          int a[10], b[10];
      
          printf("输入a数组:");
          
          for (i = 0; i < 10; i++)        //输入a数组各元素
          {
              scanf("%d", &a[i]);
          }
      
          printf("\n输入数组b:");        //输入b数组各元素
      
          for (i = 0; i < 10; i++)
          {
              scanf("%d", &b[10]);
          }
      
          for (i = 0; i < 10; i++)        //比较各元素大小,记录次数
          {
              if (large(a[i], b[i]) == 1)
                  n++;
              else if(large(a[i], b[i]) == 0)
                  m++;
              else
                  k++;
          }
      
          if (n > k)
              printf("数组a大于数组b。");
          else if(n < k)
              printf("数组a小于数组b。");
          else
              printf("数组a等于数组b");
      
          return 0;
      }
      
      int large(int x, int y)     //比大小子函数
      {
          int flag;
      
          if (x > y)
              flag = 1;
          else if (x == y)
              flag = 0;
          else
              flag = -1;
      
          return flag;
      }
      
  • 数组名做函数参数

    • 数组名代表数组的首元素的地址,数组名做函数参数时,实参与形参采用地址传递方式。对形参数组元素的改变就是对其对应的实参数组元素的改变。

    • 一维数组名做函数参数

      • 形参数组实质上是一个指针变量,指定其大小不起任何作用,因此不在数组内设定大小,但可以另立参数来传递大小。

      • 实参和形参都是数组名

        #include <stdio.h>
        #define N 9                         //定义全局变量
        void output(int a[], int n);        //声明函数
        
        int main()
        {
            int x[N], i;		//实参为数组
        
            for (i = 0; i < N; i++)     //输入数组
            {
                x[i] = 2 * i;
            }
        
            output(x, N);       //输出数组
        
            return 0;
        }
        
        void output(int a[], int n)     //输出数组子函数
        {
            int i;
        
            for (i = 0; i < n; i++)
                printf("%d ", a[i]);	
        }
        
      • 实参为指向数组的指针变量,形参为数组名

        #include <stdio.h>
        #define N 9                         //定义全局变量
        void output(int a[], int n);        //声明函数
        
        int main()
        {
            int x[N], i;
            int *q;
        
            for (i = 0; i < N; i++)     //输入数组
            {
                x[i] = 2 * i;
            }
        
            q = x;
        
            output(q, N);       //输出数组,实参为指针变量
        
            return 0;
        }
        
        void output(int a[], int n)     //输出数组子函数
        {
            int i;
        
            for (i = 0; i < n; i++)
                printf("%d ", *a++);
        }
        
        
      • 实参为数组名,形参为指针变量

        #include <stdio.h>
        #define N 9                         //定义全局变量
        void output(int *p, int n);        //声明函数
        
        int main()
        {
            int x[N], i;
        
            for (i = 0; i < N; i++)     //输入数组
            {
                x[i] = 2 * i;
            }
        
            output(x, N);       //输出数组,实参为数组名
        
            return 0;
        }
        
        void output(int *p, int n)     //输出数组子函数,形参为指针变量
        {
            int i;
        
            for (i = 0; i < n; i++)
                printf("%d ", *p++);
        }
        
        
      • 实参和形参都是指针变量

        #include <stdio.h>
        #define N 9                         //定义全局变量
        void output(int *p, int n);        //声明函数
        
        int main()
        {
            int x[N], i;
            int *p;
        
            for (i = 0; i < N; i++)     //输入数组
            {
                x[i] = 2 * i;
            }
        
            p = x;
        
            output(x, N);       //输出数组,实参为指针变量
        
            return 0;
        }
        
        void output(int *p, int n)     //输出数组子函数,形参为指针变量
        {
            int i;
        
            for (i = 0; i < n; i++)
                printf("%d ", *p++);
        }
        
    • 多维数组名做函数参数

      • 大概都和一维数组相同,但用数组名做参数时,对形参的定义中,可以指定每一维的长度,也可以不指定,但是其余各维的都必须指定
        int a[][]和int a[10][]都是不允许的。

      • #include <stdio.h>
        #include <math.h>
        int small(int a[5][5]);         //声明子函数
        
        int main()
        {
            int arr[5][5], i, j, vmin;
        
            printf("输入25个整数:");
            
            for (i = 0; i < 5; i++)         //输入数组
                for (j = 0; j < 5; j++)
                    scanf("%d", &arr[i][j]);
        
            vmin = small(arr);          //找出数组对角线最小值
        
            printf("%d", vmin);
        
            return 0;
        }
        
        int small(int a[5][5])      //找出对角线最小值
        {
            int i, vm;
        
            vm = a[0][0];
        
            for (i = 0; i < 5; i++)
            {
                if (vm > a[i][i])
                    vm = a[i][i];
        
                return vm;
            }
        }
        
        
    • 字符数组作函数参数

      • 和一维数组一样

      • #include <stdio.h>
        #include <math.h>
        #include <string.h>
        void my_copy(char str[], char *t);      //声明字符复制函数
        
        int main()
        {
            char str1[] = "I Love Beijing!";
            char str2[] = "I Love Chine!";
        
            my_copy(str1, str2);        //字符复制
        
            printf("%s", str1);
        
            return 0;
        }
        
        void my_copy(char str[], char *t)       //自定义函数
        {
            int i = 0;
        
            while (*t != '\0')
            {
                str[i] = *t;
                i++;
                t++;
            }
        
            str[i] = '\0';
        }
        
        

四、函数的嵌套调用和递归调用

1、函数的嵌套调用

  • C语言的函数定义是相互独立的,函数与函数之间没有从属关系。在一个函数内不能定义另一个函数。但是运行嵌套调用,即允许在调用一个函数的过程中,又调用另一个函数。

  • #include <stdio.h>
    int my_max(int x, int y, int z);
    int my_min(int x, int y, int z);
    int dif(int x, int y, int z);
    
    int main()          //主函数,计算最大值见最小值
    {
        int a, b, c, d;
    
        printf("输入三个整数:");
        scanf("%d%d%d", &a, &b, &c);
    
        d = dif(a, b, c);
    
        printf("max - min = %d", d);
    
        return 0;
    }
    
    int my_max(int x, int y, int z)     //找出最大值
    {
        int max1, max2;
    
        max1 = (x > y) ? x : y;
        max2 = (max1 > z) ? max1 : z;
    
        return max2;
    }
    
    int my_min(int x, int y, int z)     //找出最小值
    {
        int min1, min2;
    
        min1 = (x < y) ? x : y;
        min2 = (min1 < z) ? min1 : z;
    
        return min2;
    }
    
    int dif(int x, int y, int z)        //调用max和min自定义函数,让其相减
    {
        int max, min, d;
    
        max = my_max(x, y, z);
        min = my_min(x, y, z);
        d = max - min;
    
        return d;
    }
    

2、函数的递归调用

  • C语言允许函数递归调用。递归调用有直接调用和间接调用之分

    • 直接递归调用:在调用某函数时,又调用其函数本身叫做直接递归调用。
    • 间接递归调用:在调用a函数的过程中调用了b函数,而b函数之中又调用了a函数,这叫间接递归调用
    • 采用递归方法处理问题的关键,就是一要找出求解的递归公式, 二要确定递归结束条件
  • #include <stdio.h>
    double fac(int x);
    
    int main()      //主函数,计算阶乘
    {
        int n;
        double f;
    
        printf("输入一个整数:");
        scanf("%d", &n);
    
        f = fac(n);
    
        printf("%d! = %lf", n, f);
    
        return 0;
    }
    
    double fac(int x)       //子函数,计算阶乘
    {
        int f;
    
        if (x == 0 || x == 1)       
            f = 1;
        else
            f = x * fac(x - 1);     //直接递归调用
    
        return f;
    }
    
  • #include <stdio.h>
    int fib(int x);
    
    int main()      //主函数,求斐波那契数列
    {
        int i;
    
        for (i = 1; i <= 20; i++)
        {
            printf("%8d", fib(i));
    
            if (i % 5 == 0)
                printf("\n");
        }
    
        return 0;
    }
    
    int fib(int x)      //子函数求斐波那契数列
    {
        int f;
    
        if (x == 1 || x == 2)
            f = 1;
        else
            f = fib(x - 1) + fib(x - 2);        //递归调用
    
        return f;
    }
    

五、函数的返回值为指针

  • 函数的返回值可以是指针,即可是变量的地址。其函数定义格式为类型名 *函数名([形参列表])

  • #include <stdio.h>
    int *fun(int *x, int *y, int *z);
    
    int main()              //求三个数的最大值,以及他的地址
    {
        int a, b, c, *p;
    
        printf("输入三个整数:");
        scanf("%d%d%d", &a, &b, &c);
    
        p = fun(&a, &b, &c);
    
        printf("%d %d", p, *p);
    
        return 0;
    }
    
    int *fun(int *x, int *y, int *z)
    {
        if (*x > *y && *x > *z)
            return (x);
        
        if (*y > *x && *y > *z)
            return (y);
    
        return (z);
    }
    

六、变量的作用域和存储类别

1、局部变量及其存储类型

  • 在函数内部定义的变量叫做局部变量,局部变量的作用域仅仅局限于定义它的函数。

    • 就算在主函数内定义的变量也只在主函数内有效,主函数不能使用其他函数内定义的变量。
    • 在不同的函数中可以定义同名的变量。
    • 形参也是局部变量。
    • 在函数中的复合语句定义的局部变量,只在其复合语句中有效。
  • 自动类变量

    • 在函数内定义的变量,如果不加任何前缀,那么系统默认为自动类变量。定义自动类变量的格式为auto double a;

    • 自动类变量是在动态存储区分配单元的(因而也称动态变量),当函数结束调用时,自动类变量不复存在。

    • #include <stdio.h>
      void text_auto();
      
      int main()
      {
          int i;
      
          for (i = 0; i <= 4; i++)
              text_auto();
          
          return 0;
      }
      
      void text_auto()
      {
          int v = 0;
          printf("v = %d\n", v);
          v++;
      }
      
      //结果v全是0
      
  • 静态类变量

    • 要在函数调用结束让变量的值保留,那么可将该局部变量定义为静态局部变量。定义格式为:static int x;

    • 静态局部变量在静态存储区中分配单元,在整个程序运行期间都不会释放。

    • #include <stdio.h>
      void text_auto();
      
      int main()
      {
          int i;
      
          for (i = 0; i <= 4; i++)
              text_auto();
          
          return 0;
      }
      
      void text_auto()
      {
          static int v = 0;
          printf("v = %d\n", v);
          v++;
      }
      
      //v = 0 v = 1 v = 2 v = 3
      
    • 静态变量若未被赋初值,那么系统会默认其为0,而动态变量则是随机数。

    • 为提升效率,C程序中大部分都是自动类变量,只有必要的情况下才定义静态变量。

  • 寄存器变量

    • 有的变量用的很频繁,为了加强效率,把这个变量定义为寄存器变量,这样函数只要在寄存器中拿这个变量,就不用到内存中拿了。定义格式为:register 类型名 变量名;
    • 只有局部自定义变量才能被定义为寄存器变量,其他都不行。
    • 不能定义任意多个寄存器变量,因为寄存器数量有限。
    • 寄存器变量没有地址,所以不能取它的地址。

2、全局变量及其存储类型

  • 在函数外部定义的变量叫做外部变量,又叫全局变量,他的作用域是从变量的定义处开始执行到结束。在此作用域内全局变量可以被各个函数所使用

    • C语言设置全局变量是为了增加函数间数据联系的渠道。例如可以利用全局变量,从函数调用中得到一个以上的返回值。
    • 为了区分局部变量和全局变量,一般将全局变量的首字母大写。
  • #include <stdio.h>
    double Max = 0, Min = 0;        //定义全局变量并赋初值
    double average(double array[], int n);      //声明函数
    
    int main()
    {
        double aver, score[10];
        int i;
    
        for (i = 0; i < 10; i++)
        {
            scanf("%lf", &score[i]);
        }
    
        aver = average(score, 10);      //函数调用,计算平均值
    
        printf("Max = %lf, Min = %lf, aver = %lf", Max, Min, aver);     //输出平均值和全局变量值
    
        return 0;
    }
    
    double average(double array[], int n)       //定义函数
    {
        int i;
        double aver, sum = array[0];
        Max = Min = array[0];
    
        for (i = 1; i < n; i++)
        {
            if (array[i] > Max)
                Max = array[i];         //全局变量初值被改变
            else if (array[i] < Min)
                Min = array[i];
    
            sum += array[i];
        }
    
        aver = sum / n;
    
        return aver;
    }
    
  • 尽量少用全局变量,不然容易混乱,,,,在同一个源文件中,局部变量和全局变量可以同名,在这种情况下,全局变量会被屏蔽,即它对有局部变量的函数内部不起作用

七、内部函数和外部函数

1、内部函数

  • 内部函数又称为静态函数,只能在定义它的源文件内被调用,定义内部函数的语法格式为:static double act(int a, int b)
  • 使用内部函数,在外部源文件中可以有同名的内部函数,它们互不干扰。

2、外部函数

  • 凡是不被说明为内部函数的函数都是外部函数,外部函数可以被其他源文件调用。可以不加前缀,也可以加前缀extern。

二、学习心得

快学完了。。。

标签:调用,return,函数,记录,int,max,C语言,学习,printf
From: https://www.cnblogs.com/dragon-dai/p/17261235.html

相关文章

  • python学习者的专属linux教程
    Linux绝对和相对路径绝对路径:以根目录为起点的路径相对路径:不是以/这个根目录为源头划分的xshell快捷键:ctrl+l清屏ctrl+d退出登录ctrl+shift+......
  • python+playwright 学习-38.checkbox和radio 相关操作
    前言单选框和复选框相关操作总结locator.click()点击操作locator.check()选中locator.uncheck()不选中locator.set_checked()设置选中状态locator.is_check......
  • C++学习路线
    C++是一种高级编程语言,广泛用于开发操作系统、应用程序、游戏和各种工具。如果你想学习这门语言,以下是一个适合初学者的学习路线:第一步:学习C++基础知识在学习C++之前,你需......
  • 【问题记录】npm 重置镜像失败 -- 删除.npmrc文件即可
    1、我在A项目中对npm镜像进行重置,重置成功后查看镜像还是没变,但是其他项目的镜像都已经change过来了。2、具体操作指令:npmconfigsetregistryhttp://registry.npm.t......
  • Python 日志记录
    #coding=utf-8importosimportsys,pdbimportlogbook#pipinstallLogbookfromlogbookimportLogger,StreamHandler,FileHandler,TimedRotatingFileHandlerfrom......
  • Delphi泛型学习(一)TList<Interger>
    varList:TList;FoundIndex:Integer;begin{CreateanewList.}List:=TList.Create;{Addafewvaluestothelist.}List.AddRange([5,1,8,2,9,14,4,......
  • python+playwright 学习-37.如何在已经打开的浏览器上继续操作,绕过登录验证码
    前言有些网站的安全级别比较高,你可能想绕过登录验证,先手工打开浏览器操作登录,让playwright继续在你已经打开的浏览器上操作。selenium是可以做到这点,那么playwright也可......
  • Java学习日记
    2023.3.26学习Java打卡类型转换不同类型数据先转化为同一类型,再运算:#低--------------------→高byte,short,char-→int-→long-→float-→double例如://强制转换......
  • stm32学习笔记---i2c学习
    stm32学习笔记---i2c学习1、半双工,不能同时发送数据,一个设备发送另一个设备接受2、接受到数据有有应答3、能够挂在多个模块,且通信之间不受干扰,支持一主多从,多住多从4......
  • 器件学习---电感
    当电流通过线圈后,会产生磁场,磁感线穿过线圈,产生的磁通量与电流i有如下关系:φ=LiL即为线圈的自感系数,也就是电感的本质特性根据法拉第电磁感应定律,当通过线圈的磁通发......