51

函数

    C程序是由一组或是变量或是函数的外部对象组成的。函数是一个自我包含的
完成一定相关功能的执行代码段。我们可以把函数看成一个"黑盒子", 你只要将数
据送进去就能得到结果, 而函数内部究竟是如何工作的的, 外部程序是不知道的。
外部程序所知道的仅限于输入给函数什么以及函数输出什么。函数提供了编制程序
的手段, 使之容易读、写、理解、排除错误、修改和维护。
    C程序中函数的数目实际上是不限的, 如果说有什么限制的话, 那就是, 一个C
程序中必须至少有一个函数, 而且其中必须有一个并且仅有一个以main为名, 这个
函数称为主函数, 整个程序从这个主函数开始执行。
    C 语言程序鼓励和提倡人们把一个大问题划分成一个个子问题, 对应于解决一
个子问题编制一个函数, 因此, C 语言程序一般是由大量的小函数而不是由少量大
函数构成的, 即所谓"小函数构成大程序"。这样的好处是让各部分相互充分独立,
并且任务单一。因而这些充分独立的小模块也可以作为一种固定规格的小"构件",
用来构成新的大程序。
    C语言的一个主要特点是可以建立库函数。Turbo C2.0提供的运行程序库有400
多个函数, 每个函数都完成一定的功能, 可由用户随意调用。这些函数总的分为输
入输出函数、数学函数、字符串和内存函数、与BIOS和DOS有关的函数、字符屏幕
和图形功能函数、过程控制函数、目录函数等。对这些库函数应熟悉其功能, 只有
这样才可省去很多不必要的工作。
    本教程后半部分专门介绍Turbo C2.0的库函数, 并对每个函数都给出例程, 读
者可以将自已需要的部分以块的方式定义, 然后将此块写入文件, 这样就可以在进
入Turbo C2.0集成开发环境后, 直接调用此程序, 连接, 运行, 观察结果, 以加深
对该函数的理解。
    用户编制Turbo C语言源程序, 就是利用Turbo C的库函数。可以把所有使用的
库函数放在一个庞大的主函数里, 也可以按不同功能设计成一个个用户函数而被其
它函数调用。Turbo C2.0建议用户使用后者, 当用户编制了一些较常用的函数时,
只要将其存在函数库里, 在以后的编程中可被方便的调用而不需要再去编译它们。
连接时将会自动从相应的库中装配成所需程序。

1. 函数的说明与定义
Turbo C2.0中所有函数与变量一样在使用之前必须说明。所谓说明是指说明函
数是什么类型的函数, 一般库函数的说明都包含在相应的头文件<*.h>中, 例如标
准输入输出函数包含在stdio.h中, 非标准输入输出函数包含在io.h中, 以后在使
用库函数时必须先知道该函数包含在什么样的头文件中, 在程序的开头用#include
<*.h>或#include"*.h"说明。只有这样程序在编译, 连接时Turbo C 才知道它是提
供的库函数, 否则, 将认为是用户自己编写的函数而不能装配。

1.1 函数说明

    1. 经典方式
         其形式为: 函数类型   函数名();
    2. ANSI 规定方式
         其形式为: 函数类型函数名(数据类型形式参数, 数据类型形式
                    参数, ......);
    其中: 函数类型是该函数返回值的数据类型, 可以是以前介绍的整型(int),
长整型(long), 字符型(char), 单浮点型(float), 双浮点型(double)以及无值型
(void), 也可以是指针, 包括结构指针。无值型表示函数没有返回值。
    函数名为Turbo C2.0的标识符, 小括号中的内容为该函数的形式参数说明。可
以只有数据类型而没有形式参数, 也可以两者都有。对于经典的函数说明没有参数
信息。如:
     int putlll(int x,int y,int z,int color,char *p)/*说明一个整型函数*/
     char *name(void);               /*说明一个字符串指什函数*/
     void student(int n, char *str); /*说明一个不返回值的函数*/
     float calculate();              /*说明一个浮点型函数*/
    注意: 如果一个函数没有说明就被调用, 编译程序并不认为出错, 而将此函数
默认为整型(int)函数。因此当一个函数返回其它类型, 又没有事先说明, 编译时
将会出错。

    1.2 函数定义

    函数定义就是确定该函数完成什么功能以及怎么运行, 相当于其它语言的一个
子程序。Turbo C2.0对函数的定义采用ANSI规定的方式。即:
       函数类型函数名(数据类型形式参数; 数据类型形式参数...)
      {
          函数体;
       }
    其中函数类型和形式参数的数据类型为Turbo C2.0的基本数据类型。函数体为
Turbo C2.0提供的库函数和语句以及其它用户自定义函数调用语句的组合, 并包括
在一对花括号"{"和"}"中。
    需要指出的是一个程序必须有一个主函数, 其它用户定义的子函数可以是任意
多个, 这些函数的位置也没有什么限制, 可以在main()函数前, 也可以在其后。
Turbo C2.0将所有函数都被认为是全局性的。而且是外部的, 即可以被另一个文件
中的任何一个函数调用。

2 函数的调用

    2.1 函数的简单调用
    Turbo C2.0调用函数时直接使用函数名和实参的方法, 也就是将要赋给被调用
函数的参量, 按该函数说明的参数形式传递过去, 然后进入子函数运行, 运行结束
后再按子函数规定的数据类型返回一个值给调用函数。使用Turbo C2.0的库函数就
是函数简单调用的方法。举例说明如下:
    例1:
     #include<stdio.h>
     int maxmum(int x, int y, int z);   /*说明一个用户自定义函数*/
     int main()
     {
          int i, j, k;
          printf("i, j, k=?\n");
          scanf("%4d%4d%4d", &i, &j, &k);
          maxmum(i, j, k);
          getch();
          return 0;
     }

     maxmum(int x, int y, int z)
     {
          int max;
          max=x>y?x:y;
          max=max>z?max:z;
          printf("The maxmum value of the 3 data is %d\n", max);
     }

    2.2 函数参数传递

    一、调用函数向被调用函数以形式参数传递
    用户编写的函数一般在对其说明和定义时就规定了形式参数类型, 因此调用这
些函数时参量必须与子函数中形式参数的数据类型、顺序和数量完全相同, 否则在
调用中将会出错, 得到意想不到的结果。
    注意:
    当数组作为形式参数向被调用函数传递时, 只传递数组的地址, 而不是将整个
数组元素都复制到函数中去, 即用数组名作为实参调用子函数, 调用时指向该数组
第一个元素的指针就被传递给子函数。因为在Turbo C2.0中, 没有下标的数组名就
是一个指向该数组第一个元素的指针。当然数组变量的类型在两个函数中必须相同。
    用下述方法传递数组形参。
    例2:
     #include<stdio.h>
     void disp(int *n);
     int main()
     {
          int m[10], i;
          for(i=0; i<10; i++)
            m[i]=i;
          disp(m);       /*按指针方式传递数组*/
          getch();
          return 0;
     }
     void disp(int *n)
     {
          int j;
          for(j=0; j<10; j++)
            printf("%3d", *(n++));
          printf("\n");
     }
    另外, 当传递数组的某个元素时, 数组元素作为实参, 此时按使用其它简单变
量的方法使用数组元素。例2按传递数组元素的方法传递时变为:
     #include<stdio.h>
     void disp(int n);
     int main()
     {
          int m[10], i;
          for(i=0; i<10; i++){
            m[i]=i;
            disp(m[i]); /*逐个传递数组元素*/
          }
          getch();
          return 0;
     }
     void disp(int n)
     {
          printf("%3d\t");
     }
这时一次只传递了数组的一个元素。

二、被调用函数向调用函数返回值

    一般使用return语句由被调用函数向调用函数返回值, 该语句有下列用途:
    1. 它能立即从所在的函数中退出, 返回到调用它的程序中去。
    2. 返回一个值给调用它的函数。
    有两种方法可以终止子函数运行并返回到调用它的函数中: 一是执行到函数的
最后一条语句后返回; 一是执行到语句return时返回。前者当子函数执行完后仅返
回给调用函数一个0。若要返回一个值, 就必须用return语句。只需在return 语句
中指定返回的值即可。例1返回最大值时变为:
     例3:
     #include<stdio.h>
     int maxmum(int x, int y, int z);   /*说明一个用户自定义函数*/
     int main()
     {
          int i, j, k, max;
          printf("i, j, k=?\n");
          scanf("%4d%4d%4d", &i, &j, &k);
          max=maxmum(i, j, k);     /*调用子函数, 并将返回值赋给max*/
          printf("The maxmum value is %d\n", max);
          getch();
          return 0;
     }

     maxmum(int x, int y, int z)
     {
          int max;
          max=x>y?x:y;        /*求最大值*/
          max=max>z?max:z;
          return(max);        /*返回最大值*/
     }
    return语句可以向调用函数返回值, 但这种方法只能返回一个参数, 在许多情
况下要返回多个参数, 这是用return语句就不能满足要求。Turob C2.0提供了另一
种参数传递的方法, 就是调用函数向被调用函数传递的形式参数不是传递变量本身,
而是传递变量的地址, 当子函数中向相应的地址写入不同的数值之后, 也就改变了
调用函数中相应变量的值, 从而达到了返回多个变量的目的。
     例4:
     #include<stdio.h>
     void subfun(int *m, int *n); /*说明子函数*/
     int main()
     {
          int i, j;
          printf("i, j=?\n");
          scanf("%d, %d", &i, &j); /*从键盘输入2个整数*/
          printf("In main before calling\n"/*输出此2数及其乘积*/
                 "i=%-4d j=%-4d i*j=%-4d\n", i, j, i*j);
          subfun(&i, &j);          /*以传送地址的方式调用子函数*/
          printf("In main after calling\n"/*调用子函数后输出变量值*/
                 "i=%-4d j=%-4d i*j=%-4d\n", i, j, i*j);
          getch();
          return 0;
     }
     void subfun(int *m, int *n)
     {
          *m=*m+2;
          *j=*i-*j;
          printf("In subfun after calling\n" /*子函数中输出变量值*/
                 "i=%-4d j=%-4d i*j=%-4d\n", *i, *j, *i**j);
      }

    上例中, *i**j表示指针i和j所指的两个整型数*i和*j之乘积。
    另外, return语句也可以返回一个指针, 举例如下。
    下例中先等待输入一字符串, 再等待输入要查找的字符, 然后调用match() 函
数在字符串中查找该字符。若有相同字符, 则返回一个指向该字符串中这一位置的
指针, 如果没有找到, 则返回一个空(NULL)指针。
    例5:
     #include<stdio.h>
     char *match(char c, char *s);
     int main()
     {
          char s[40], c, *str;
          str=malloc(40);          /*为字符串指什分配内存空间*/
          printf("Please input character string:");
          gets(s);                 /*键盘输入字符串*/
          printf("Please input one character:");
          c=getche();              /*键盘输入字符*/
          str=match(c, s);         /*调用子函数*/
          putchar('\n');
          puts(str);               /*输出子函数返回的指针所指的字符串*/
          getch();
          return 0;
     }
     char *match(char c, char *s)
     {
          int i=0;
          while(c!=s[i]&&s[i]!='\n')/*找字符串中指定的字符*/
               i++;
          return(&s[i]);           /*返回所找字符的地址*/
     }

    三、用全程变量实现参数互传
    以上两种办法可以在调用函数和被调用函数间传递参数, 但使用不太方便。如
果将所要传递的参数定义为全程变量, 可使变量在整个程序中对所有函数都可见。
这样相当于在调用函数和被调用函数之间实现了参数的传递和返回。这也是实际中
经常使用的方法, 但定义全程变量势必长久地占用了内存。因此, 全程变量的数目
受到限制, 特别对于较大的数组更是如此。当然对于绝大多数程序内存都是够用的。
    例6:
     #incluide<stdio.h>
     void disp(void);
     int m[10];          /*定义全程变量*/
     int main()
     {
          int i;
          printf("In main before calling\n");
          for(i=0; i<10; i++){
            m[i]=i;
            printf("%3d", m[i]);   /*输出调用子函数前数组的值*/
          }
          disp();                  /*调用子函数*/
          printf("\nIn main after calling\n");
          for(i=0; i<10; i++)
            printf("%3d", m[i]);   /*输出调用子函数后数组的值*/
          getch();
          return 0;
     }
     void disp(void)
     {
          int j;
          printf("In subfunc after calling\n");/*子函数中输出数组的值*/
          for (j=0; i<10; j++){
               m[j]=m[j]*10;
               printf("%3d", m[i]);
          }
     }

    2.3 函数的递归调用
    Turbo C2.0允许函数自己调用自己, 即函数的递归调用, 递归调用可以使程序
简洁、代码紧凑, 但要牺牲内存空间作处理时的堆栈。
    如要求一个n!(n的阶乘)的值可用下面递归调用:
    例8:
      #include<stdio.h>
      unsigned ling mul(int n);
      int main()
     {
          int m;
          puts("Calculate n! n=?\n");
          scanf("%d", &m);         /*键盘输入数据*/
          printf("%d!=%ld\n", m, mul(m));/*调用子程序计算并输出*/
          getch();
          retun 0;
      }
     unsigned long mul(int n)
     {
          unsigned long p;
          if(n>1)
               p=n*mul(n-1);       /*递归调用计算n!*/
          else
               p=1L;
          return(p);               /*返回结果*/
     }
运行结果:
          calculate n! n=?
输入5时结果为:
          5!=120

    3. 函数作用范围

    Turbo C2.0中每个函数都是独立的代码块, 函数代码归该函数所有, 除了对函
数的调用以外, 其它任何函数中的任何语句都不能访问它。例如使用跳转语句goto
就不能从一个函数跳进其它函数内部。除非使用全程变量, 否则一个函数内部定义
的程序代码和数据, 不会与另一个函数内的程序代码和数据相互影响。
    Turbo C2.0中所有函数的作用域都处于同一嵌套程度, 即不能在一个函数内再
说明或定义另一个函数。
    Turbo C2.0中一个函数对其它子函数的调用是全程的, 即是函数在不同的文件
中, 也不必附加任何说明语句而被另一函数调用, 也就是说一个函数对于整个程序
都是可见的。

    4. 函数的变量作用域
    在Turbo C2.0中, 变是可以在各个层次的子程序中加以说明, 也就是说, 在任
何函数中, 变量说明有只允许在一个函数体的开头处说明, 而且允许变量的说明(
包括初始化)跟在一个复合语句的左花括号的后面, 直到配对的右花括号为止。它
的作用域仅在这对花括号内, 当程序执行到出花括号时, 它将不复存在。当然, 内
层中的变量即使与外层中的变量名字相同, 它们之间也是没有关系的。
    例9.
     #include<stdio.h>
     int i=10;
     int main()
     {
          int i=1;
          printf("%d\t, i);
          {
               int i=2;
               pritnf("%d\t", i);
               {
                    extern i;
                    i+=1;
                    printf("%d\t", i);
               }
               printf("%d\t", ++i);
          }
          printf("%d\n", ++i);
          return 0;
     }
运行结果为
     1    2    11   3    2
从程序运行的结果不难看出程序中各变量之间的关系, 以及各个变量的作用域。

返回目录