C语言基础学习day07

函数

一个较大的程序可分为若干个程序模块，每一个模块用来实现一个特定的功能。 在高级语言中用子程序实现模块的功能。子程序由函数来完成。 一个Ｃ程序可由一个主函数和若干个其他函数构成。

函数间的调用关系

由主函数调用其他函数，其他函数也可以互相调用。同一个函数可以被一个或多个函数调用任意多次。

# include <stdio.h>
void main()
{
  void printstar();           /*对printstar函数声明*/
  void print_message();
                                        /*对print_message函数声明*/
  printstar();                 ／*调用printstar函数*／
  print_message();         /*调用print_message函数*/
  printstar();                 ／*调用printstar函数*/
 }
void printstar() ／*定义printstar函数*／
{
 printf("* * * * * * * * * * * * * * * *
");
}

void print_message() ／*定义print_message函数*／
{
  printf("How do you do!
");
 }

说明：

（1）一个Ｃ程序由一个或多个程序模块组成，每一个程序模块作为一个源程序文件。对较大的程序，一般不希望把所有内容全放在一个文件中，而是将他们分别放在若干个源文件中，再由若干源程序文件组成一个C程序。这样便于分别编写、分别编译，提高调试效率。一个源程序文件可以为             多个C程序公用。

（2） 一个源程序文件由一个或多个函数以及其他有关内容（如命令行、数据定义等）组成。一个源程序文件是一个编译单位，在程序编译时是以源程序文件为单位进行编译的，而不是以函数为单位进行编译的。

（3）Ｃ程序的执行是从ｍａｉｎ函数开始的，如是在ｍａｉｎ函数中调用其他函数，在调用后流程返回到ｍａｉｎ函数，在ｍａｉｎ函数中结束整个程序的运行。

（4） 所有函数都是平行的，即在定义函数时是分别进行的，是互相独立的。一个函数并不从属于另一函数，即函数不能嵌套定义。函数间可以互相调用，但不能调用ｍａｉｎ函数。ｍａｉｎ函数是系统调用的。

关于函数返回值的一些说明

1. 在Ｃ语言中，凡不加类型说明的函数，自动按整型处理。

2. 在定义函数时指定的函数类型一般应该和return语句中的表达式类型一致。

3. 如果函数值的类型和return语句中表达式的值不一致，则以函数类型为准。对数值型数据，可以自动进行类型转换。即函数类型决定返回值的类型。

4. 对于不带回值的函数，应当用“void”定义函数为“无类型”（或称“空类型”）。

实参求值的顺序

如果实参表列包括多个实参，对实参求值的顺序并不是确定的，有的系统按自左至右顺序求实参的值，有的系统则按自右至左顺序。 许多Ｃ版本是按自右而左的顺序求值,例如Tubro Ｃ++

#include <stdio.h>
void main()
  {
   int f(int a,int b);  /* 函数声明 */
   int i=2,p;
   p=f(i,++i);        /*  函数调用 */
   printf("%d
",p);
  } 　 
int f(int a,int b)              /*  函数定义 */
{
  int c;
  if(a>b) c=1;
   else if(a==b) c=0;
          else c=-1;
   return(c);//结果是0
}　　 　 

 

 

对被调用函数的声明和函数原型

(1) 首先被调用的函数必须是已经存在的函数（是库函数或用户自己定义的函数）。但光有这一条件还不够。

(2) 如果使用库函数，还应该在本文件开头用＃ｉｎｃｌｕｄｅ命令将调用有关库函数时所需用到的信息“包含”到本文件中来。

(3) 如果使用用户自己定义的函数，而该函数的位置在调用它的函数（即主调函数）的后面（在同一个文件中），应该在主调函数中对被调用的函数作声明。

函数的“定义”和“声明”不是一回事。函数的定义是指对函数功能的确立，包括指定函数名，函数值类型、形参及其类型、函数体等，它是一个完整的、独立的函数单位。（占内存）

而函数的声明的作用则是把函数的名字、函数类型以及形参的类型、个数和顺序通知编译系统，以便在调用该函数时系统按此进行对照检查。（不占内存）

如果 被调用函数的定义出现在主调函数之前，可以不必加以声明。因为编译系统已经先知道了已定义函数的有关情况，会根据函数首部提供的信息对函数的调用作正确性检查。

 练习

1.自己实现pow()函数并尝试验证

double power( double x, double y );

void main( void )
{
      double x = 3.0, y = 3.0, z;
      
      z = power( x, y );
      
      printf( "%.1f to the power of %.1f is %.1f
", x, y, z );
}

double power( double x, double y )
{
      double z = x; //定义变量最好赋一个初值

      while( --y )
      {
            z *= x;
      }

      return z;
}

输出结果：3.0 to the power of 3.0 is 27.0

2.猜想下sqrt()函数的原理并尝试编程……（暂时只要求整型数据）

#include <stdio.h>

int sqrt_02( int question );

void main( void )
{
      int question = 50, answer;
      
      answer = sqrt_02( question );

      if( answer < 0 )
            printf( "Error: sqrt returns %d
, answer" );
      else
            printf( "The square root of %d is %d
", question, answer );
}

int sqrt_02( int question )
{
      int temp = question/2;

      while( temp-- ) 
      {
            if( temp * temp == question )
                  return temp;
      }

      return -1;
}

函数的嵌套调用

嵌套定义就是在定义一个函数时，其函数体内又包含另一个函数的完整定义。 然而，Ｃ语言不能嵌套定义函数，但可以嵌套调用函数，也就是说，在调用一个函数的过程中，又调用另一个函数。

main(){
        a();
}

a(){
    b();
}

b(){
    return;
}

递归

在调用一个函数的过程中又出现直接或间接地调用该函数本身，称为函数的递归调用。Ｃ语言的特点之一就在于允许函数的递归调用。

递归必须要有一个退出的条件！

用递归的方法求 n! 求ｎ！也可以用递归方法，即５！等于４！×５，而４！＝３！×４…１！＝１。

可用下面的递归公式表示：

ｎ＝１ （ｎ＝０，１）

ｎ *（ｎ－１）！ （ｎ＞１）

#include <stdio.h>

long recursion(int n);

void main()
{
    int n;
    long result;
    
    printf("input a integer number:
");
    scanf("%d", &n);

    result = recursion(n);
    printf("%d! = %ld
", n, result);
}

long recursion(int n)
{
    long temp_result;

    if( n < 0)
    {
        printf("n < 0, input error!
");
    }
    else if( n==0 || n==1 )
    {
        temp_result = 1;
    }
    else
    {
        temp_result = recursion(n-1) * n;
    }

    return temp_result;
}

数组作为函数参数

数组可以作为函数的参数使用，进行数据传送。数组用作函数参数有两种形式。

一种是把数组元素(下标变量)作为实参使用；

另一种是把数组名作为函数的形参和实参使用

数组元素作函数实参

数组元素就是下标变量，它与普通变量并无区别。因此它作为函数实参使用与普通变量是完全相同的，在发生函数调用时，把作为实参的数组元素的值传送给形参，实现单向的值传送

例题训练 判别一个整数数组a[10]={1, 2, 3, 4, -1, -2, -3, -4, 2, 3}中各元素的值，若大于0 则输出该值，若小于等于0则输出0值。

#include <stdio.h>

void test(int v);

void main()
{
      int a[10] = {1, 2, 3, 4, -1, -2, -3, -4, 2, 3};
      int i;
      
      for(i=0; i < 10; i++)
      {
            test(a[i]);
      }
      
      printf("
");
}

void test(int v)
{
      if(v>0)
      {
            printf("%d ", v);
      }
      else
      {
            printf("%d ", 0);
      }
}

数组名作函数参数

用数组名作函数参数与用数组元素作实参有几点不同：

1) 用数组元素作实参时，只要数组类型和函数的形参变量的类型一致，那么作为下标变量的数组元素的类型也和函数形参变量的类型是一致的。因此，并不要求函数的形参也是下标变量。换句话说，对数组元素的处理是按普通变量对待的。

    然而，用数组名作函数参数时，则要求形参和相对应的实参都必须是类型相同的数组，都必须有明确的数组说明。当形参和实参二者不一致时，即会发生错误。

2) 在普通变量或下标变量作函数参数时，形参变量和实参变量是由编译系统分配的两个不同的内存单元。在函数调用时发生的值传送是把实参变量的值赋予形参变量。

    在用数组名作函数参数时，不是进行值的传送，而是址传递，即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。

因为实际上形参数组并不存在，编译系统不为形参数组分配内存。

数组名就是数组的首地址。因此在数组名作函数参数时所进行的传送只是地址的传送，也就是说把实参数组的首地址赋予形参数组名。

形参数组名取得该首地址之后，也就等于有了实在的数组。实际上是形参数组和实参数组为同一数组，共同拥有一段内存空间。

#include <stdio.h>

void test(int b[10]);
void main()
{
      int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
      test(a);

      putchar('
');
}

void test(int b[10])
{
      int i = 0;

      for( ; i < 10; i++ )
      {
            printf("%d ", b[i]);
      }
}

a和b指向同一个地址

内存数组的存储：

有一个一维数组ｓｃｏｒｅ，内放１０个学生成绩，求平均成绩（写一个average函数求平均成绩）。

#include <stdio.h>

double average(double array[]);  /* 函数声明 */

void main()
{
 
      double score[10] = {82, 100, 87.5, 89, 78, 85, 67.5, 92.5, 93, 94}, result;

      result = average(score);
      printf("average score is %5.2lf
", result);

      putchar('
');
}

double average(double array[])
{
      double result = 0;
      int i = 0;
      
      for( i=0; i < 10; i++ )
      {
            result += array[i];
      }
      result /= 10;

      return result;
}

局部变量和全局变量

局部变量 

在一个函数内部定义的变量是内部变量，它只在本函数范围内有效，也就是说只有在本函数内才能使用它们，在此函数以外是不能使用这些变量的。这称为“局部变量”。

float f1( int a)           /*函数f1 */
{
   int b,c;
…                     a、b、c有效
}                 
char f2(int x,int y)       /*函数f2 */
{ 
    int i,j;                 x、y、i、j有效
} 
void main( )               /*主函数*/
{
    int m,n;
…                         m、n有效
} 　

说明：

(1) 主函数中定义的变量(m,n)也只在主函数中有效,而不因为在主函数中定义而在整个文件或程序中有效。主函数也不能使用其他函数中定义的变量。

(2) 不同函数中可以使用相同名字的变量,它们代表不同的对象,互不干扰。例如, 上面在f1函数中定义了变量b和c,倘若在f2函数中也定义变量b和c,它们在内存中占不同的单元,互不混淆。

(3) 形式参数也是局部变量。例如上面f1函数中的形参a,也只在f1函数中有效。其他函数可以调用f1函数，但不能引用f1函数的形参a。

(4) 在一个函数内部,可以在复合语句中定义变量,这些变量只在本复合语句中有效,这种复合语句也称为“分程序”或“程序块”。

void main ( )
{
   int a,b;
…
    {
       int c;
       c=a+b;  c在此范围内有效   a,b在此范围内有效
 … 
    }
…
} 　

 全局变量

1. 在函数内定义的变量是局部变量,而在函数之外定义的变量称为外部变量,外部变量是全局变量(也称全程变量)。

2. 全局变量可以为本文件中其他函数所共用。它的有效范围为从定义变量的位置开始到本源文件结束。

int p=1,q=5;                /* 外部变量 */
float f1(int a)            /* 定义函数f1 */
{int b,c;
…                           
}
char c1,c2;                 /* 外部变量*/
char f2 (int x, int y)      /* 定义函数f2 */
{int i,j;                       
 …                        
}
void main ( )               /*主函数*/
{int m,n;
…
} 　　

建议不在必要时不要使用全局变量，原因如下：

① 全局变量在程序的全部执行过程中都占用存储单元，而不是仅在需要时才开辟单元。

② 使用全局变量过多，会降低程序的清晰性，人们往往难以清楚地判断出每个瞬时各个外部变量的值。在各个函数执行时都可能改变外部变量的值，程序容易出错。因此，要限制使用全局变量。

③它使函数的通用性降低了，因为函数在执行时要依赖于其所在的外部变量。

   如果将一个函数移到另一个文件中，还要将有关的外部变量及其值一起移过去。

   但若该外部变量与其他文件的变量同名时，就会出现问题，降低了程序的可靠性和通用性。 一般要求把Ｃ程序中的函数做成一个封闭体，除了可以通过“实参——形参”的渠道与外界发生联系外，没有其他渠道。

变量的存储类别

动态存储方式与静态存储方式

从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。

那么从变量值存在的时间（即生存期）角度来分，又可以分为静态存储方式和动态存储方式

所谓静态存储方式是指在程序运行开始时由系统分配固定的存储空间的方式。

而动态存储方式则是在程序运行期间根据需要进行动态的分配存储空间的方式。

用户存储空间可以分为三部分：

1. 程序区

2. 静态存储区

3. 动态存储区

在Ｃ语言中每一个变量和函数有两个属性：数据类型和数据的存储类别。

对于数据类型（如整型、字符型等）。

存储类别指的是数据在内存中存储的方式。

存储方式分为两大类：静态存储类和动态存储类。

具体包含四种：自动的（auto），静态的（static），寄存器的（register），外部的（extern）。

根据变量的存储类别，可以知道变量的作用域和生存期。

auto变量

函数中的局部变量，如不专门声明为static存储类别，都是动态地分配存储空间的(栈)，数据存储在动态存储区中。

函数中的形参和在函数中定义的变量(包括在复合语句中定义的变量)，都属此类，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间

因此这类局部变量称为自动变量。自动变量用关键字auto作存储类别的声明。

int ｆ（int ａ）  ／*定义f函数，ａ为形参 *／
｛   auto  int ｂ，ｃ＝３；  ／*定义ｂ、ｃ为自动变量 *／
      …………
  ｝

关键字auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。

用static声明局部变量

有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次该函数调用时，该变量已有值，就是上一次函数调用结束时的值。

这时就应该指定该局部变量为“静态局部变量”，用关键字static进行声明。 通过下面简单的例子可以了解它的特点。

/*********************************/
/* 该小程序考察静态局部变量的值。*/
/*********************************/
#include <stdio.h>

int f(int a) 
{
      auto int b = 0;
      static int c = 3;
     
      b = b + 1; // b == 1 , 1 , 1
      c = c + 1; // c == 4 , 5 , 6
      
      return (a+b+c); // 7 , 8 , 9
      
}

void main()
{
      int a=2, i;

      for(i=0; i < 3; i++)
      {
            printf("%d
", f(a)); 
      }
}

对静态局部变量的说明

(1) 静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。

      而自动变量（即动态局部变量）属于动态存储类别，占动态存储区空间而不占静态存储区空间，函数调用结束后即释放。

(2) 对静态局部变量是在编译时赋初值的，即只赋初值一次，在程序运行时它已有初值。 以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。

     而对自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

(3)如在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值０（对数值型变量）或空字符（对字符变量）。

    而对自动变量来说，如果不赋初值则它的值是一个不确定的值。 这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。

(4) 虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的

/*********************/
/* 打印1到5的阶乘值。*/
/*********************/

#include <stdio.h>

int fac(int n)
{
      static int f = 1;
      
      f = f * n; // 1, 2, 2*3, 6*4, 24*5
      
      return (f); // 1, 2, 6, 24, 120
}

void main()
{
      int i;

      for(i=1; i <= 5; i++)
      {
            printf("%d! = %d
", i, fac(i)); // 1, 2, 6, 24, 120
      }

}

 register变量 

一般情况下，变量（包括静态存储方式和动态存储方式）的值是存放在内存中的。

当程序中用到哪一个变量的值时，由控制器发出指令将内存中该变量的值送到运算器中。经过运算器进行运算，如果需要存数，再从运算器将数据送到内存存放。

如果有一些变量使用频繁（例如在一个函数中执行１００００次循环，每次循环中都要引用某局部变量），则为存取变量的值要花费不少时间。

为提高执行效率，Ｃ语言允许将局部变量的值放在CPU中的寄存器中，需要用时直接从寄存器取出参加运算，不必再到内存中去存取。

由于对寄存器的存取速度远高于对内存的存取速度，因此这样做可以提高执行效率。这种变量叫做寄存器变量，用关键字register作声明。

例如，输出１到n的阶乘的值

/*********************/
/* 打印1到5的阶乘值。*/
/*    改进版本!!     */
/*********************/

#include <stdio.h>

int fac(int n)   //注意，这个版本不用static特性，所以把阶乘的过程放在fac()函数中实现。
{
      register int i, f = 1;  
      
      for(i=1; i <= n; i++)
      {
            f *= i;
      }
      
      return (f);
}

void main()
{
      int i;

      for(i=1; i <= 15; i++)
      {
            printf("%d! = %d
", i, fac(i));
      }

}

用extern声明外部变量

外部变量即全局变量，它的作用域是从变量的定义处开始，到本程序文件的末尾。

在此作用域内，全局变量可以为程序中各个函数所引用。编译时将外部变量分配在静态存储区。 有时需要用extern来声明外部变量，以扩展外部变量的作用域

编译器是从上往下执行的

示例：

/*************************************************/
/* 用extern声明外部变量，扩展程序文件中的作用域。*/
/*************************************************/

#include <stdio.h>

int max(int x, int y)
{
      int z;

      z = x>y ? x : y;

      return(z);
}


void main()
{ 
      extern A, B;  //试试去掉extern关键字。

      printf("%d
", max(A, B));

}

int A = 13, B = -8;

在多文件的程序中声明外部变量

>>>file1.c

#include <stdio.h>

int A;                     /*定义外部变量*/

void main()                          
{
      int power(int);          /*函数声明*/
      int b = 3, c, result, m;

      printf("enter the number A and its power m:
");
      scanf("%d %d", &A, &m);
      
      c = A * b;
      printf("%d * %d = %d
", A, b, c);

      result = power(m);
      printf("%d ^ %d = %d
", A, m, result);
}

>>>file2.c

extern  A; /*声明A为一个已定义的外部变量*/

int power(int n) 
{
      int i, y = 1;

      for(i=1; i <= n; i++)
      {
            y *= A;
      }

      return y;
}

用static声明外部变量

有时在程序设计中希望某些外部变量只限于本文件引用，而不能被其他文件引用，这时可以在定义外部变量时加一个static声明

#include <stdio.h>

static int A;                     /*这里我们增加了static不让别的文件引用*/

void main()                          
{
      int power(int);          /*函数声明*/
      int b = 3, c, d, m;

      printf("enter the number a and its power m:
");
      scanf("%d %d", &A, &m);
      
      c = A * b;
      printf("%d * %d = %d
", A, b, c);

      d = power(m);
      printf("%d ^ %d = %d
", A, m, d);
}

小结：

1. 从作用域角度分，有局部变量和全局变量，它们采用的存储类别如下：

    局部变量

    全局变量

2. 从变量存在的时间来区分，有动态存储和静态存储两种类型，静态存储是程序整个运行时间都存在，而动态存储则是在调用函数时临时分配单元

3. 从变量值存放的位置来区分，可分为：

    内存中静态存储区

    内存中动态存储区

    CPU中寄存器

4. 关于作用域和生存期的概念

5. static对局部变量和全局变量的作用不同，对局部变量来说，它使变量由动态存储方式改变为静态存储方式，而对全局变量来说，它使变量局部化（局部于本文件），但仍为静态存储方式

    从作用域角度看，凡有static声明的，其作用域都是局限的，或者是局限于本函数内，或者局限于本文件内

内部函数和外部函数

函数本质上是全局的，因为一个函数要被另一个函数调用，但是，也可以指定函数不能被其他文件调用

根据函数能否被其他源文件调用，将函数区分为内部函数和外部函数

内部函数

在定义内部函数时，在函数名和函数类型的前面加static

static 类型标识符 函数名（形参表）

static int fun （int a，int b）

外部函数

在定义函数时，如果在函数首部的最左端加关键字extern，则表示此函数是外部函数，可供其他文件调用，如函数首部可以写为

extern int fun（int a，int b）

C语言规定，如果在定义函数时省略extern，则隐含为外部函数