首页 > 代码库 > C语言函数

C语言函数

2024-08-26 07:18:39   217人阅读

1.C语言函数概述

在前面已经介绍过，C源程序是由函数组成的。虽然在前面各章的程序中大都只有一个主函数main()，但实用程序往往由多个函数组成。函数是C源程序的基本模块，通过对函数模块的调用实现特定的功能。C语言中的函数相当于其它高级语言的子程序。C语言不仅提供了极为丰富的库函数（如Turbo C，MS C都提供了三百多个库函数），还允许用户建立自己定义的函数。用户可把自己的算法编成一个个相对独立的函数模块，然后用调用的方法来使用函数。可以说C程序的全部工作都是由各式各样的函数完成的，所以也把C语言称为函数式语言。
 
由于采用了函数模块式的结构，C语言易于实现结构化程序设计。使程序的层次结构清晰，便于程序的编写、阅读、调试。
 
在C语言中可从不同的角度对函数分类。
 
1) 从函数定义的角度看，函数可分为库函数和用户定义函数两种。
  1. 库函数：由C系统提供，用户无须定义，也不必在程序中作类型说明，只需在程序前包含有该函数原型的头文件即可在程序中直接调用。在前面各章的例题中反复用到printf、scanf、getchar、putchar、gets、puts、strcat等函数均属此类。
  2. 用户定义函数：由用户按需要写的函数。对于用户自定义函数，不仅要在程序中定义函数本身，而且在主调函数模块中还必须对该被调函数进行类型说明，然后才能使用。
 
2) 语言的函数兼有其它语言中的函数和过程两种功能，从这个角度看，又可把函数分为有返回值函数和无返回值函数两种。
  1. 有返回值函数：此类函数被调用执行完后将向调用者返回一个执行结果，称为函数返回值。如数学函数即属于此类函数。由用户定义的这种要返回函数值的函数，必须在函数定义和函数说明中明确返回值的类型。
  2. 无返回值函数：此类函数用于完成某项特定的处理任务，执行完成后不向调用者返回函数值。这类函数类似于其它语言的过程。由于函数无须返回值，用户在定义此类函数时可指定它的返回为“空类型”，空类型的说明符为“void”。
 
3) 从主调函数和被调函数之间数据传送的角度看又可分为无参函数和有参函数两种。
  1. 无参函数：函数定义、函数说明及函数调用中均不带参数。主调函数和被调函数之间不进行参数传送。此类函数通常用来完成一组指定的功能，可以返回或不返回函数值。
  2. 有参函数：也称为带参函数。在函数定义及函数说明时都有参数，称为形式参数(简称为形参)。在函数调用时也必须给出参数，称为实际参数(简称为实参)。进行函数调用时，主调函数将把实参的值传送给形参，供被调函数使用。
 
4) C语言提供了极为丰富的库函数，这些库函数又可从功能角度作以下分类。
  1. 字符类型分类函数：用于对字符按ASCII码分类：字母，数字，控制字符，分隔符，大小写字母等。
  2. 转换函数：用于字符或字符串的转换；在字符量和各类数字量(整型，实型等)之间进行转换；在大、小写之间进行转换。
  3. 目录路径函数：用于文件目录和路径操作。
  4. 诊断函数：用于内部错误检测。
  5. 图形函数：用于屏幕管理和各种图形功能。
  6. 输入输出函数：用于完成输入输出功能。
  7. 接口函数：用于与DOS，BIOS和硬件的接口。
  8. 字符串函数：用于字符串操作和处理。
  9. 内存管理函数：用于内存管理。
  10. 数学函数：用于数学函数计算。
  11. 日期和时间函数：用于日期，时间转换操作。
  12. 进程控制函数：用于进程管理和控制。
  13. 其它函数：用于其它各种功能。
 
以上各类函数不仅数量多，而且有的还需要硬件知识才会使用，因此要想全部掌握则需要一个较长的学习过程。应首先掌握一些最基本、最常用的函数，再逐步深入。由于课时关系，我们只介绍了很少一部分库函数，其余部分读者可根据需要查阅C语言函数手册。
 
还应该指出的是，在C语言中，所有的函数定义，包括主函数main在内，都是平行的。也就是说，在一个函数的函数体内，不能再定义另一个函数，即不能嵌套定义。但是函数之间允许相互调用，也允许嵌套调用。习惯上把调用者称为主调函数。函数还可以自己调用自己，称为递归调用。
 
main 函数是主函数，它可以调用其它函数，而不允许被其它函数调用。因此，C程序的执行总是从main函数开始，完成对其它函数的调用后再返回到main函数，最后由main函数结束整个程序。一个C源程序必须有，也只能有一个主函数main。

2.C语言函数的定义

本节讲解有参函数和无参函数的定义。

①.无参函数的定义

 
无参函数定义的一般形式如下：
    类型标识符  函数名(){
        声明部分
        语句
    }
其中类型标识符和函数名称为函数头。类型标识符指明了本函数的类型，函数的类型实际上是函数返回值的类型。该类型标识符与前面介绍的各种说明符相同。函数名是由用户定义的标识符，函数名后有一个空括号，其中无参数，但括号不可少。
 
{}中的内容称为函数体。在函数体中声明部分，是对函数体内部所用到的变量的类型说明。
 
在很多情况下都不要求无参函数有返回值，此时函数类型符可以写为void。
 
我们可以改写一个函数定义：
  1. void Hello(){
  2.     printf ("Hello,world \n");
  3. }

这里，只把main改为Hello作为函数名，其余不变。Hello函数是一个无参函数，当被其它函数调用时，输出Hello world字符串。

②.有参函数定义的一般形式

 
有参函数定义的一般形式如下：
    类型标识符  函数名(形式参数表列){
        声明部分
        语句
    }
有参函数比无参函数多了一个内容，即形式参数表列。在形参表中给出的参数称为形式参数，它们可以是各种类型的变量，各参数之间用逗号间隔。在进行函数调用时，主调函数将赋予这些形式参数实际的值。形参既然是变量，必须在形参表中给出形参的类型说明。
 
例如，定义一个函数，用于求两个数中的大数，可写为：
  1. int max(int a, int b){
  2.     if (a>b) return a;
  3.     else return b;
  4. }

第一行说明max函数是一个整型函数，其返回的函数值是一个整数。形参为a,b,均为整型量。a,b的具体值是由主调函数在调用时传送过来的。在{}中的函数体内，除形参外没有使用其它变量，因此只有语句而没有声明部分。在max函数体中的return语句是把a(或b)的值作为函数的值返回给主调函数。有返回值函数中至少应有一个return语句。
 
在C程序中，一个函数的定义可以放在任意位置，既可放在主函数main之前，也可放在main之后。例如：可把max 函数置在main之后，也可以把它放在main之前。修改后的程序如下所示。
 
【例8-1】函数定义示例
  1. #include <stdio.h>
  2. int max(int a,int b){
  3.     if(a>b)return a;
  4.     else return b;
  5. }
  6. int main(void){
  7.     int max(int a,int b);
  8.     int x,y,z;
  9.     printf("input two numbers:\n");
  10.     scanf("%d%d",&x,&y);
  11.     z=max(x,y);
  12.     printf("maxmum=%d",z);
  13.     return 0;
  14. }

现在我们可以从函数定义、函数说明及函数调用的角度来分析整个程序，从中进一步了解函数的各种特点。
 
程序的第1行至第4行为max函数定义。进入主函数后，因为准备调用max函数，故先对max函数进行说明（程序第6行）。函数定义和函数说明并不是一回事，在后面还要专门讨论。 可以看出函数说明与函数定义中的函数头部分相同，但是末尾要加分号。程序第10行为调用max函数，并把x、y中的值传送给max的形参a、b。max函数执行的结果（a或b）将返回给变量z。最后由主函数输出z的值。

3.C语言函数的调用

前面已经说过，在程序中是通过对函数的调用来执行函数体的，其过程与其它语言的子程序调用相似。C语言中，函数调用的一般形式为：
    函数名(实际参数表);
对无参函数调用时则无实际参数表。实际参数表中的参数可以是常数，变量或其它构造类型数据及表达式。各实参之间用逗号分隔。

①.函数调用的方式

 
在C语言中，可以用以下几种方式调用函数。
 
1) 函数表达式
函数作为表达式中的一项出现在表达式中，以函数返回值参与表达式的运算。这种方式要求函数是有返回值的。例如：
z=max(x,y);
是一个赋值表达式，把max的返回值赋予变量z。
 
2) 函数语句
函数调用的一般形式加上分号即构成函数语句。例如：
  1. printf ("%d",a);
  2. scanf ("%d",&b);

都是以函数语句的方式调用函数。
 
3) 函数实参
函数作为另一个函数调用的实际参数出现。这种情况是把该函数的返回值作为实参进行传送，因此要求该函数必须是有返回值的。例如：
  1. printf("%d",max(x,y));

即是把max调用的返回值又作为printf函数的实参来使用的。在函数调用中还应该注意的一个问题是求值顺序的问题。所谓求值顺序是指对实参表中各量是自左至右使用呢，还是自右至左使用。对此，各系统的规定不一定相同。介绍printf 函数时已提到过，这里从函数调用的角度再强调一下。
 
【例8-3】在VC6.0下运行以下代码。
  1. #include <stdio.h>
  2. int main(void){
  3.     int i=8;
  4.     printf("%d %d %d %d\n",++i,++i,--i,--i);
  5.     return 0;
  6. }

运行结果：
8 7 6 7
 
可见是按照从右至左的顺序求值。
 
如果按照从左至右求值，结果应为：
9  10  9  8
 
应特别注意的是，无论是从左至右求值， 还是自右至左求值，其输出顺序都是不变的，即输出顺序总是和实参表中实参的顺序相同。
 

②.被调用函数的声明和函数原型

 
在主调函数中调用某函数之前应对该被调函数进行说明（声明），这与使用变量之前要先进行变量说明是一样的。在主调函数中对被调函数作说明的目的是使编译系统知道被调函数返回值的类型，以便在主调函数中按此种类型对返回值作相应的处理。其一般形式为：
        类型说明符  被调函数名( 类型 形参, 类型 形参… );
或为：
        类型说明符  被调函数名( 类型, 类型…);
括号内给出了形参的类型和形参名，或只给出形参类型。这便于编译系统进行检错，以防止可能出现的错误。
 
【例8-1】main函数中对max函数的说明为：
  1. int max( int a, int b );

或写为:
  1. int max( int, int );

 
C语言中又规定在以下几种情况时可以省去主调函数中对被调函数的函数说明。
 
1) 如果被调函数的返回值是整型或字符型时，可以不对被调函数作说明，而直接调用。这时系统将自动对被调函数返回值按整型处理。【例8-2】的主函数中未对函数s作说明而直接调用即属此种情形。
 
2) 当被调函数的函数定义出现在主调函数之前时，在主调函数中也可以不对被调函数再作说明而直接调用。例如【例8-1】中，函数max的定义放在main 函数之前，因此可在main函数中省去对max函数的函数说明int max(int a,int b)。
 
3) 如在所有函数定义之前，在函数外预先说明了各个函数的类型，则在以后的各主调函数中，可不再对被调函数作说明。例如：
  1. char str(int a);
  2. float f(float b);
  3. main(){
  4.     /* ...... */
  5. }
  6. char str(int a){
  7.     /* ...... */
  8. }
  9. float f(float b){
  10.     /* ...... */
  11. }

其中第一，二行对str函数和f函数预先作了说明。因此在以后各函数中无须对str和f函数再作说明就可直接调用。对库函数的调用不需要再作说明，但必须把该函数的头文件用include命令包含在源文件前部。

4.C语言函数的嵌套调用

C语言中不允许作嵌套的函数定义。因此各函数之间是平行的，不存在上一级函数和下一级函数的问题。但是C语言允许在一个函数的定义中出现对另一个函数的调用。这样就出现了函数的嵌套调用。即在被调函数中又调用其它函数。这与其它语言的子程序嵌套的情形是类似的。其关系可表示如图。
 技术分享
 
图表示了两层嵌套的情形。其执行过程是：执行main函数中调用a函数的语句时，即转去执行a函数，在a函数中调用b 函数时，又转去执行b函数，b函数执行完毕返回a函数的断点继续执行，a函数执行完毕返回main函数的断点继续执行。
【例8-4】计算s = 22! + 32!
本题可编写两个函数，一个是用来计算平方值的函数f1，另一个是用来计算阶乘值的函数f2。主函数先调f1计算出平方值，再在f1中以平方值为实参，调用 f2计算其阶乘值，然后返回f1，再返回主函数，在循环程序中计算累加和。
  1. #include <stdio.h>
  2. long f1(int p){
  3.     int k;
  4.     long r;
  5.     long f2(int);
  6.     k=p*p;
  7.     r=f2(k);
  8.     return r;
  9. }
  10. long f2(int q){
  11.     long c=1;
  12.     int i;
  13.     for(i=1;i<=q;i++)
  14.         c=c*i;
  15.     return c;
  16. }
  17. int main(void){
  18.     int i;
  19.     long s=0;
  20.     for (i=2;i<=3;i++)
  21.         s=s+f1(i);
  22.     printf("\ns=%ld\n",s);
  23.     return 0;
  24. }

在程序中，函数f1和f2均为长整型，都在主函数之前定义，故不必再在主函数中对f1和f2加以说明。在主程序中，执行循环程序依次把i值作为实参调用函数f1求i2值。在f1中又发生对函数f2的调用，这时是把i2的值作为实参去调f2，在f2 中完成求i2!的计算。f2执行完毕把C值(即i2!)返回给f1，再由f1返回主函数实现累加。至此，由函数的嵌套调用实现了题目的要求。由于数值很大，所以函数和一些变量的类型都说明为长整型，否则会造成计算错误。

5.C语言函数的递归调用

一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。C语言允许函数的递归调用。在递归调用中，主调函数又是被调函数。执行递归函数将反复调用其自身，每调用一次就进入新的一层。例如有函数f如下：
  1. int f(int x){
  2.     int y;
  3.     z=f(y);
  4.     return z;
  5. }

这个函数是一个递归函数。但是运行该函数将无休止地调用其自身，这当然是不正确的。为了防止递归调用无终止地进行，必须在函数内有终止递归调用的手段。常用的办法是加条件判断，满足某种条件后就不再作递归调用，然后逐层返回。下面举例说明递归调用的执行过程。
 
【例8-5】用递归法计算n!
 
用递归法计算n!可用下述公式表示：
    n!=1          (n=0,1)
    n*(n-1)!    (n>1)
按公式可编程如下：
  1. #include <stdio.h>
  2. long ff(int n){
  3.     long f;
  4.     if(n<0) printf("n<0,input error");
  5.     else if(n==0||n==1) f=1;
  6.     else f=ff(n-1)*n;
  7.     return(f);
  8. }
  9. int main(void){
  10.     int n;
  11.     long y;
  12.     printf("\ninput a inteager number:\n");
  13.     scanf("%d",&n);
  14.     y=ff(n);
  15.     printf("%d!=%ld",n,y);
  16.     return 0;
  17. }

程序中给出的函数ff是一个递归函数。主函数调用ff 后即进入函数ff执行，如果n<0,n==0或n=1时都将结束函数的执行，否则就递归调用ff函数自身。由于每次递归调用的实参为n-1，即把n-1的值赋予形参n，最后当n-1的值为1时再作递归调用，形参n的值也为1，将使递归终止。然后可逐层退回。
 
下面我们再举例说明该过程。设执行本程序时输入为5，即求5!。在主函数中的调用语句即为y=ff(5)，进入ff函数后，由于n=5,不等于0或1，故应执行f=ff(n-1)*n,即f=ff(5-1)*5。该语句对ff作递归调用即ff(4)。
 
进行四次递归调用后，ff函数形参取得的值变为1，故不再继续递归调用而开始逐层返回主调函数。ff(1)的函数返回值为1，ff(2)的返回值为1*2=2，ff(3)的返回值为2*3=6，ff(4)的返回值为6*4=24，最后返回值ff(5)为24*5=120。

6.C语言数组作为函数参数

数组用作函数参数有两种形式，一种是把数组元素（下标变量）作为实参使用；另一种是把数组名作为函数的形参和实参使用。

①.数组元素作函数实参

 
数组元素就是下标变量，它与普通变量并无区别。 因此它作为函数实参使用与普通变量是完全相同的，在发生函数调用时，把作为实参的数组元素的值传送给形参，实现单向的值传送。【例5-4】说明了这种情况。
 
【例8-7】判别一个整数数组中各元素的值，若大于0 则输出该值，若小于等于0则输出0值。编程如下：
  1. #include <stdio.h>
  2. void nzp(int v){
  3.     if(v>0)
  4.         printf("%d ",v);
  5.     else
  6.         printf("%d ",0);
  7. }
  8. int main(void){
  9.     int a[5],i;
  10.     printf("input 5 numbers\n");
  11.     for(i=0;i<5;i++){
  12.         scanf("%d",&a[i]);
  13.         nzp(a[i]);
  14.     }
  15.     return 0;
  16. }

本程序中首先定义一个无返回值函数nzp，并说明其形参v为整型变量。在函数体中根据v值输出相应的结果。在main函数中用一个for语句输入数组各元素，每输入一个就以该元素作实参调用一次nzp函数，即把a[i]的值传送给形参v，供nzp函数使用。

②.数组名作为函数参数

 
用数组名作函数参数与用数组元素作实参有几点不同。
 
1) 用数组元素作实参时，只要数组类型和函数的形参变量的类型一致，那么作为下标变量的数组元素的类型也和函数形参变量的类型是一致的。因此，并不要求函数的形参也是下标变量。换句话说，对数组元素的处理是按普通变量对待的。用数组名作函数参数时，则要求形参和相对应的实参都必须是类型相同的数组，都必须有明确的数组说明。当形参和实参二者不一致时，即会发生错误。
 
2) 在普通变量或下标变量作函数参数时，形参变量和实参变量是由编译系统分配的两个不同的内存单元。在函数调用时发生的值传送是把实参变量的值赋予形参变量。在用数组名作函数参数时，不是进行值的传送，即不是把实参数组的每一个元素的值都赋予形参数组的各个元素。因为实际上形参数组并不存在，编译系统不为形参数组分配内存。那么，数据的传送是如何实现的呢?在我们曾介绍过，数组名就是数组的首地址。因此在数组名作函数参数时所进行的传送只是地址的传送，也就是说把实参数组的首地址赋予形参数组名。形参数组名取得该首地址之后，也就等于有了实在的数组。实际上是形参数组和实参数组为同一数组，共同拥有一段内存空间。
 技术分享
 
上图说明了这种情形。图中设a为实参数组，类型为整型。a占有以2000为首地址的一块内存区。b为形参数组名。当发生函数调用时，进行地址传送，把实参数组a的首地址传送给形参数组名b，于是b也取得该地址2000。于是a，b两数组共同占有以2000为首地址的一段连续内存单元。从图中还可以看出a和b下标相同的元素实际上也占相同的两个内存单元（整型数组每个元素占二字节）。例如a[0]和b[0]都占用2000和2001单元，当然a[0]等于b[0]。类推则有a[i]等于b[i]。
 
【例8-8】数组a中存放了一个学生5门课程的成绩，求平均成绩。
  1. #include <stdio.h>
  2. float aver(float a[5]){
  3.     int i;
  4.     float av,s=a[0];
  5.     for(i=1;i<5;i++)
  6.         s=s+a[i];
  7.     av=s/5;
  8.     return av;
  9. }
  10. int main(void){
  11.     float sco[5],av;
  12.     int i;
  13.     printf("\ninput 5 scores:\n");
  14.     for(i=0;i<5;i++)
  15.         scanf("%f",&sco[i]);
  16.     av=aver(sco);
  17.     printf("average score is %5.2f",av);
  18.     return 0;
  19. }

本程序首先定义了一个实型函数aver，有一个形参为实型数组a，长度为5。在函数aver中，把各元素值相加求出平均值，返回给主函数。主函数main 中首先完成数组sco的输入，然后以sco作为实参调用aver函数，函数返回值送av，最后输出av值。 从运行情况可以看出，程序实现了所要求的功能。
 
3) 前面已经讨论过，在变量作函数参数时，所进行的值传送是单向的。即只能从实参传向形参，不能从形参传回实参。形参的初值和实参相同，而形参的值发生改变后，实参并不变化，两者的终值是不同的。而当用数组名作函数参数时，情况则不同。由于实际上形参和实参为同一数组，因此当形参数组发生变化时，实参数组也随之变化。当然这种情况不能理解为发生了“双向”的值传递。但从实际情况来看，调用函数之后实参数组的值将由于形参数组值的变化而变化。为了说明这种情况，把【例5.4】改为【例5.6】的形式。
 
【例8-9】题目同【例8.7】。改用数组名作函数参数。
  1. #include <stdio.h>
  2. void nzp(int a[5]){
  3.     int i;
  4.     printf("\nvalues of array a are:\n");
  5.     for(i=0;i<5;i++){
  6.         if(a[i]<0) a[i]=0;
  7.         printf("%d ",a[i]);
  8.     }
  9. }
  10. int main(void){
  11.     int b[5],i;
  12.     printf("\ninput 5 numbers:\n");
  13.     for(i=0;i<5;i++)
  14.         scanf("%d",&b[i]);
  15.     printf("initial values of array b are:\n");
  16.     for(i=0;i<5;i++)
  17.         printf("%d ",b[i]);
  18.     nzp(b);
  19.     printf("\nlast values of array b are:\n");
  20.     for(i=0;i<5;i++)
  21.         printf("%d ",b[i]);
  22.     return 0;
  23. }

本程序中函数nzp的形参为整数组a，长度为5。主函数中实参数组b也为整型，长度也为5。在主函数中首先输入数组b的值，然后输出数组b的初始值。然后以数组名b为实参调用nzp函数。在nzp中，按要求把负值单元清0，并输出形参数组a的值。 返回主函数之后，再次输出数组b的值。从运行结果可以看出，数组b的初值和终值是不同的，数组b的终值和数组a是相同的。这说明实参形参为同一数组，它们的值同时得以改变。
 
用数组名作为函数参数时还应注意以下几点：
①形参数组和实参数组的类型必须一致，否则将引起错误。
 
②形参数组和实参数组的长度可以不相同，因为在调用时，只传送首地址而不检查形参数组的长度。当形参数组的长度与实参数组不一致时，虽不至于出现语法错误(编译能通过)，但程序执行结果将与实际不符，这是应予以注意的。
 
【例8.10】如把例8.9修改如下：
  1. #include <stdio.h>
  2. void nzp(int a[8]){
  3.     int i;
  4.     printf("\nvalues of array aare:\n");
  5.     for(i=0;i<8;i++){
  6.         if(a[i]<0)a[i]=0;
  7.         printf("%d ",a[i]);
  8.     }
  9. }
  10. int main(void){
  11.     int b[5],i;
  12.     printf("\ninput 5 numbers:\n");
  13.     for(i=0;i<5;i++)
  14.         scanf("%d",&b[i]);
  15.     printf("initial values of array b are:\n");
  16.     for(i=0;i<5;i++)
  17.         printf("%d ",b[i]);
  18.     nzp(b);
  19.     printf("\nlast values of array b are:\n");
  20.     for(i=0;i<5;i++)
  21.         printf("%d ",b[i]);
  22.     return 0;
  23. }

本程序与【例8.9】程序比，nzp函数的形参数组长度改为8，函数体中，for语句的循环条件也改为i<8。因此，形参数组a和实参数组b的长度不一致。编译能够通过，但从结果看，数组a的元素a[5]、a[6]、a[7]显然是无意义的。
 
③在函数形参表中，允许不给出形参数组的长度，或用一个变量来表示数组元素的个数。例如，可以写为：
    void nzp(int a[])
或写为
    void nzp( int a[], int n )
其中形参数组a没有给出长度，而由n值动态地表示数组的长度。n的值由主调函数的实参进行传送。由此，【例8-10】又可改为【例8-11】的形式。
 
【例8-11】
  1. #include <stdio.h>
  2. void nzp(int a[],int n){
  3.     int i;
  4.     printf("\nvalues of array a are:\n");
  5.     for(i=0;i<n;i++){
  6.         if(a[i]<0) a[i]=0;
  7.         printf("%d ",a[i]);
  8.     }
  9. }
  10. int main(void){
  11.     int b[5],i;
  12.     printf("\ninput 5 numbers:\n");
  13.     for(i=0;i<5;i++)
  14.         scanf("%d",&b[i]);
  15.     printf("initial values of array b are:\n");
  16.     for(i=0;i<5;i++)
  17.         printf("%d ",b[i]);
  18.     nzp(b,5);
  19.     printf("\nlast values of array b are:\n");
  20.     for(i=0;i<5;i++)
  21.         printf("%d ",b[i]);
  22.     return 0;
  23. }

本程序nzp函数形参数组a没有给出长度，由n 动态确定该长度。在main函数中，函数调用语句为nzp(b，5)，其中实参5将赋予形参n作为形参数组的长度。
 
④多维数组也可以作为函数的参数。在函数定义时对形参数组可以指定每一维的长度，也可省去第一维的长度。因此，以下写法都是合法的：
    int MA(int a[3][10])
或
    int MA(int a[][10])。

7.C语言局部变量和全局变量

在讨论函数的形参变量时曾经提到，形参变量只在被调用期间才分配内存单元，调用结束立即释放。这一点表明形参变量只有在函数内才是有效的，离开该函数就不能再使用了。这种变量有效性的范围称变量的作用域。不仅对于形参变量，C语言中所有的量都有自己的作用域。变量说明的方式不同，其作用域也不同。
 
C语言中的变量，按作用域范围可分为两种，即局部变量和全局变量。

①.局部变量

 
局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内， 离开该函数后再使用这种变量是非法的。例如：
  1. int f1(int a){
  2.     int b,c;  /* a,b,c仅在函数f1()内有效 */
  3. }
  4. int f2(int x){
  5.     int y,z;  /* x,y,z仅在函数f2()内有效 */
  6. }
  7. main(){
  8.     int m,n;  /* m,n仅在函数main()内有效 */
  9. }

在函数f1内定义了三个变量，a为形参，b、c为一般变量。在 f1的范围内a、b、c有效，或者说a、b、c变量的作用域限于f1内。同理，x、y、z的作用域限于f2内。m、n的作用域限于main函数内。
 
关于局部变量的作用域还要说明以下几点：
  1. 主函数中定义的变量也只能在主函数中使用，不能在其它函数中使用。同时，主函数中也不能使用其它函数中定义的变量。因为主函数也是一个函数，它与其它函数是平行关系。这一点是与其它语言不同的，应予以注意。
  2. 形参变量是属于被调函数的局部变量，实参变量是属于主调函数的局部变量。
  3. 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰，也不会发生混淆。如在前例中，形参和实参的变量名都为n，是完全允许的。
  4. 在复合语句中也可定义变量，其作用域只在复合语句范围内。例如：
  1. main(){
  2.     int s,a;
  3.     /* …… */
  4.     {
  5.         int b;
  6.         s=a+b;
  7.         /* ……*/    /*b作用域*/
  8.     }
  9.     /* …… */    /*s,a作用域*/
  10. }

 
【例8-12】
  1. #include <stdio.h>
  2. int main(void){
  3.     int i=2, j=3, k;
  4.     k=i+j;
  5.     {
  6.         int k=8;
  7.         printf("%d\n",k);
  8.     }
  9.     printf("%d\n",k);
  10.     return 0;
  11. }

本程序在main中定义了i、j、k三个变量，其中k未赋初值。而在复合语句内又定义了一个变量k，并赋初值为8。应该注意这两个k不是同一个变量。在复合语句外由main定义的k起作用，而在复合语句内则由在复合语句内定义的k起作用。因此程序第3行的k为main所定义，其值应为5。第6行输出k值，该行在复合语句内，由复合语句内定义的k起作用，其初值为8，故输出值为8，第8行输出i，k值。i是在整个程序中有效的，第6行对i赋值为3，故以输出也为3。而第8行已在复合语句之外，输出的k应为main所定义的k，此k值由第3 行已获得为5，故输出也为5。

②.全局变量

 
全局变量也称为外部变量，它是在函数外部定义的变量。它不属于哪一个函数，它属于一个源程序文件。其作用域是整个源程序。
 
在函数中使用全局变量，一般应作全局变量说明。只有在函数内经过说明的全局变量才能使用。全局变量的说明符为extern。但在一个函数之前定义的全局变量，在该函数内使用可不再加以说明。例如：

从上例可以看出a、b、x、y 都是在函数外部定义的外部变量，都是全局变量。但x、y 定义在函数f1之后，而在f1内又无对x、y的说明，所以它们在f1内无效。a、b定义在源程序最前面，因此在f1、f2及main内不加说明也可使用。
 
【例8-13】输入正方体的长宽高l、w、h。求体积及三个面x*y、x*z、y*z的面积。
  1. #include <stdio.h>
  2. int s1,s2,s3;
  3. int vs( int a,int b,int c){
  4.     int v;
  5.     v=a*b*c;
  6.     s1=a*b;
  7.     s2=b*c;
  8.     s3=a*c;
  9.     return v;
  10. }
  11. int main(void){
  12.     int v,l,w,h;
  13.     printf("input length,width and height: ");
  14.     scanf("%d %d %d",&l,&w,&h);
  15.     v=vs(l,w,h);
  16.     printf("v=%d, s1=%d, s2=%d, s3=%d\n",v,s1,s2,s3);
  17.     return 0;
  18. }

 
【例8-14】外部变量与局部变量同名。
  1. #include <stdio.h>
  2. int a=3, b=5;  /* a,b为外部变量 */
  3. int max(int a,int b){  /* a,b为外部变量 */
  4.     int c;
  5.     c=a>b ? a : b;
  6.     return c;
  7. }
  8. int main(void){
  9.     int a=8;
  10.     printf("%d\n",max(a,b));
  11.     return 0;
  12. }

如果同一个源文件中，外部变量与局部变量同名，则在局部变量的作用范围内，外部变量被“屏蔽”，即它不起作用。

8.C语言变量的存储类别

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

 
前面已经介绍了，从变量的作用域（即从空间）角度来分，可以分为全局变量和局部变量。
 
从另一个角度，从变量值存在的作时间（即生存期）角度来分，可以分为静态存储方式和动态存储方式。
  1. 静态存储方式：是指在程序运行期间分配固定的存储空间的方式。
  2. 动态存储方式：是在程序运行期间根据需要进行动态的分配存储空间的方式。
 
用户存储空间可以分为三个部分：
程序区；
静态存储区；
动态存储区。
 
全局变量全部存放在静态存储区，在程序开始执行时给全局变量分配存储区，程序行完毕就释放。在程序执行过程中它们占据固定的存储单元，而不动态地进行分配和释放。
 
动态存储区存放以下数据：
函数形式参数；
自动变量（未加static声明的局部变量）；
函数调用实的现场保护和返回地址。
 
对以上这些数据，在函数开始调用时分配动态存储空间，函数结束时释放这些空间。
 
在C语言中，每个变量和函数有两个属性：数据类型和数据的存储类别。

②.auto变量

 
函数中的局部变量，如不专门声明为static存储类别，都是动态地分配存储空间的，数据存储在动态存储区中。
 
函数中的形参和在函数中定义的变量（包括在复合语句中定义的变量），都属此类，在调用该函数时系统会给它们分配存储空间，在函数调用结束时就自动释放这些存储空间。这类局部变量称为自动变量。自动变量用关键字auto作存储类别的声明。例如：
  1. int f(int a){  /* 定义f函数，a为参数 */
  2.     auto int b,c=3;  /*定义b，c自动变量*/
  3.     /* …… */
  4. }

a是形参，b，c是自动变量，对c赋初值3。执行完f函数后，自动释放a，b，c所占的存储单元。
 
关键字auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。

③.用static声明局部变量

 
有时希望函数中的局部变量的值在函数调用结束后不消失而保留原值，这时就应该指定局部变量为“静态局部变量”，用关键字static进行声明。
 
【例8-15】考察静态局部变量的值。
  1. #include <stdio.h>
  2. int f(int a){
  3.     auto int b=0;
  4.     static int c=3;
  5.     b=b+1;
  6.     c=c+1;
  7.     return (a+b+c);
  8. }
  9. int main(void){
  10.     int a=2,i;
  11.     for(i=0;i<3;i++)
  12.         printf("%d\n",f(a));
  13.     return 0;
  14. }

 
对静态局部变量的说明：
  1. 静态局部变量属于静态存储类别，在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，占动态存储空间，函数调用结束后即释放。
  2. 静态局部变量在编译时赋初值，即只赋初值一次；而对自动变量赋初值是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。
  3. 如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）。而对自动变量来说，如果不赋初值则它的值是一个不确定的值。
 
【例8-16】打印1到5的阶乘值。
  1. #include <stdio.h>
  2. int fac(int n){
  3.     static int f=1;
  4.     f=f*n;
  5.     return f;
  6. }
  7. int main(void){
  8.     int i;
  9.     for(i=1;i<=5;i++)
  10.         printf("%d!=%d\n",i,fac(i));
  11.     return 0;
  12. }

④.register变量

 
为了提高效率，C语言允许将局部变量得值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。
 
【例8-17】使用寄存器变量。
  1. #include <stdio.h>
  2. int fac(int n){
  3.     register int i,f=1;
  4.     for(i=1;i<=n;i++)
  5.         f=f*i;
  6.     return f;
  7. }
  8. int main(void){
  9.     int i;
  10.     for(i=0;i<=5;i++)
  11.         printf("%d!=%d\n",i,fac(i));
  12.     return 0;
  13. }

 
对寄存器变量的几点说明：
  1. 只有局部自动变量和形式参数可以作为寄存器变量；
  2. 一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；
  3. 局部静态变量不能定义为寄存器变量。

⑤.用extern声明外部变量

 
外部变量（即全局变量）是在函数的外部定义的，它的作用域为从变量定义处开始，到本程序文件的末尾。如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该外部变量，则应该在引用之前用关键字extern对该变量作“外部变量声明”。表示该变量是一个已经定义的外部变量。有了此声明，就可以从“声明”处起，合法地使用该外部变量。
 
【例8-18】用extern声明外部变量，扩展程序文件中的作用域。
  1. #include <stdio.h>
  2. int max(int x,int y){
  3.     int z;
  4.     z=x>y?x:y;
  5.     return z;
  6. }
  7. int main(void){
  8.     extern A,B;
  9.     printf("%d\n",max(A,B));
  10.     return 0;
  11. }
  12. int A=13, B=-8;

说明：在本程序文件的最后1行定义了外部变量A、B，但由于外部变量定义的位置在函数main之后，因此本来在main函数中不能引用外部变量A、B。现在我们在main函数中用extern对A和B进行“外部变量声明”，就可以从“声明”处起，合法地使用该外部变量A和B。




来自为知笔记(Wiz)


C语言函数


联系
我们