第五章   函数

    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
     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
     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
     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
     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
     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
     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
     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
      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
     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
从程序运行的结果不难看出程序中各变量之间的关系, 以及各个变量的作用域。

                    Turbo C 程序设计初步

    本节主要介绍Turbo C程序设计的基本步骤及如何编译、调试和运行源程序。
并给出Turbo C的常用编辑命令。最后介绍Turbo C编译、连接和运行时的常见错
误。

    一、Turbo C程序设计基本步骤

    程序设计方法包括三个基本步骤:
    第一步:  分析问题。
    第二步:  画出程序的基本轮廓。
    第三步:  实现该程序。
      3a. 编写程序
      3b. 测试和调试程序
      3c. 提供数据打印结果
    下面, 我们来说明每一步的具体细节。

    第一步: 分析问题
    在这一步, 你必须:
    a. 作为解决问题的一种方法, 确定要产生的数据(输出)。作为这一子步的
一部分, 你应定义表示输出的变量。
    b. 确定需产生输出的数据(称为输入), 作为这一子步的一部分,  你应定义
表示输入的变量。
    c. 研制一种算法, 从有限步的输入中获取输出。 这种算法定义为结构化的
顺序操作, 以便在有限步内解决问题。就数字问题而言, 这种算法包括获取输出
的计算, 但对非数字问题来说, 这种算法包括许多文本和图象处理操作。

    第二步: 画出程序的基本轮廓
    在这一步, 你要用一些句子(伪代码)来画出程序的基本轮廓。每个句子对应
一个简单的程序操作。对一个简单的程序来说,  通过列出程序顺序执行的动作,
便可直接产生伪代码。然而, 对复杂一些的程序来说, 则需要将大致过程有条理
地进行组织。对此, 应使用自上而下的设计方法。
    当使用自上而下的设计方法时, 你要把程序分割成几段来完成。列出每段要
实现的任务, 程序的轮廓也就有了, 这称之为主模块。当一项任务列在主模块时,
仅用其名加以标识, 并未指出该任务将如何完成。这方面的内容留给程序设计的
下一阶段来讨论。将程序分为几项任务只是对程序的初步设计。整个程序设计归
结为下图所示的流程图1.。
                                   ┏━━━━━━━━━━━━━━━┓
                                   ┃           主模块             ┃
  ┏━━━━━━━┓               ┃ 输入数据                     ┃
  ┃   主模块     ┃               ┃ 计算购房所需的金额           ┃
  ┃              ┃               ┃ 计算装修所需的金额           ┃
  ┃ 任务1        ┃               ┃ 计算总金额                   ┃
  ┃ 任务2        ┃               ┃ 输出计算结果                 ┃
  ┃ 任务3        ┃               ┃                              ┃
  ┃ 任务4        ┃               ┗━━━━━━━┳━━━━━━━┛
  ┃              ┃       ┏━━━━━┳━━━━━╋━━━━┳━━━━━┓
  ┃              ┃ ┏━━┻━┓┏━━┻━┓┏━━┻━┓┏━┻━┓┏━━┻━┓
  ┗━━━━━━━┛ ┃输入数据┃┃购房额..┃┃装修额..┃┃总额..┃┃输出结果┃
                     ┗━━━━┛┗━━━━┛┗━━━━┛┗━━━┛┗━━━━┛
   图1. 程序初步设计                    图2. 第二级程序设计

    如果把主模块的每项任务扩展成一个模块, 并根据子任务进行定义的话, 那
么, 程序设计就更为详细了(见图2.)。这些模块称为主模块的子模块。程序中许
多子模块之间的关系可象图2.中那样归结为一张图。这种图称为结构图。
    要画出模块的轮廓, 你可不考虑细节。如果这样的话, 你必须使用子模块,
将各个模块求精, 达到第三级设计。继续这一过程, 直至说明程序的全部细节。
这一级一级的设计过程称为逐步求精法。在编写程序之前, 对你的程序进行逐步
求精, 对你来说, 是很好的程序设计实践, 会使你养成良好的设计习惯。
    我们则才描述了程序设计中自上而下的设计方法。实际上就是说, 我们设计
程序是从程序的"顶部"开始一直考虑到程序的"底部"。

    第三步: 实现该程序
    程序设计的最后一步是编写源码程序。 在这一步,  把模块的伪代码翻译成
Turbo C语句。
    对于源程序, 你应包含注释方式的文件编制, 以描述程序各个部分做何种工
作。此外, 源程序还应包含调试程序段, 以测试程序的运行情况, 并允许查找编
程错误。一旦程序运行情况良好, 可去掉调试程序段, 然而,  文件编制应做为源
程序的固定部分保留下来, 便于你或其他人维护和修改。
    二、源程序的输入、编译和运行

    C语言是一种中级语言, 用户用C语言编写的程序称为源程序, 存放用C 语言
所写源程序文件名字最后的两个字符一般必须为".c"。计算机硬件不能直接执行
源程序, 必须将源程序翻译成二进制目标程序。翻译工作是由一个程序完成的,
这个程序称为编译程序, 翻译的过程称为编译, 编译的结果称为目标程序, 存放
目标程序文件名字紧后的字符一般为".OBJ"或".O"。程序翻译成目标程序后, 便
可进行连接。"连接"的目的是使程序变成在计算机上可以执行的最终形式。在这
一阶段, 从系统程序库来的程序要与目标程序连接, 连接的结果称为执行程序,
存放执行程序文件名字一般以".EXE"结尾。
    在Turbo C集成开发环境中建立一个新程序通常有以下几个步骤:
    (1). 在编辑器中编写源文件。
    (2). 生成可执行文件。

    在DOS提示符下键入TC, 即可进入Turbo C了。进入主TC屏后, 按F3键, 即可
在随之出现的框中输入文件名, 文件名可以带".C"也可以不带( 此时系统会自动
加上)。输入文件名后, 按回车, 即可将文件调入, 如果文件不存在,  就建立一
个新文件(也可用下面例子中的方法输入文件名)。系统随之进入编辑状态。就可
以输入或修改源程序了, 源程序输入或修改完毕以后, 按Ctrl+F9(同时按下Ctrl
键和F9键), 则立即进行编译、连接和执行, 这三项工作是连续完成的。
    下面我们试着建立一个Turbo C名为"HELLO.C"的源程序(因程序很小, 这里就
不画出该程序的轮廓图了):
    1. 操作步骤:
    (1). 将系统置于DOS提示符下:
    (2). 键入命令:
          tc hello.c
使系统进入Turbo C集成开发环境, 并建立一个名为HELLO.C的文件。这时, 系统
进入Turbo C编辑环境。
    (3). 通过键盘输入程序, 例如:
     main()
     {
          printf("Hello, world\n");
     }
则程序进入计算机存贮器。
    2. 程序存盘
    为防止意外事故丢失程序, 最好将输入的程序存贮到磁盘中。在编辑窗口下,
可直接按F2键或按F10键, 再按F键进入File菜单项, 再按S或W键将文件存盘。存
盘时屏幕最底行会显示:
     "saving edit file"
    3. 编译一个程序
    对源程序进行编译有两种方法: (1). 直接按Alt+F9即可。(2). 按F10 键返
回主菜单, 选择Compile项,  屏幕显示Compile 下拉菜单,   从下拉菜单中选择
Compile to .OBJ项, 按回车键。
    进入编译状态后, 屏幕会出现一个编译窗口, 几秒钟后, 屏幕显示一闪烁信
息:
          Success: press any key
表示编译成功。此时可按任意键, 编译窗口消失, 光标返回主菜单。
    如果编译时产生警告Warning或出错Error信息, 这些具体错误信息会显示在
屏幕下部的信息窗中, 必须纠正这些错误。对源程序进行修改, 重新进行编译。
    4. 运行程序
    源程序经编译无误后, 可以投入运行。具体操作如下:
    (1). 如果当前还在编辑状态, 可按Alt+R, 再选择RUN项即可。
    (2). 按Ctrl+F9。
    程序投入运行时, 屏幕会出现一个连接窗口, 显示Turbo C 正在连接和程序
所需的库函数。连接完毕后, 会出现屏幕突然一闪, 后又回到TC主屏幕, 发生了
什么? 让我们按Alt+F5看看, 此时屏幕被清除, 在顶部显示"Hello, world"字样。
再按任意键, 即可又回到TC主屏幕。
    5. 列磁盘文件目录
    现在请按Alt+X退出Turbo C, 返回DOS提示符, 键入dir hello.*, 回车, 则
屏幕显示:
     HELLO   C       42   1-09-93  10:18
     HELLO   OBJ    221   1-09-93  10:22
     HELLO   EXE   4486   1-09-93  10:25
     ...
    第一个文件HELLO.C是源文件文本, 在DOS提示符下键入TYPE HELLO.C命令,
可在屏幕上显示该文件的内容。可看到该程序只有42个字节。
    第二个文件HELLO.OBJ是Turbo C编择程序产生的二进制机器指令(目标码),
如果用DOS命令TYPE显示该文件, 屏幕可能会出现混乱的信息。
    第三个文件HELLO.EXE是Turbo C连接程序产生的实际可执行文件。在DOS 提
示符下键入HELLO并按回车, 屏幕将显示"Hello, world"。

    Turbo C 常用的编辑命令


    Turbo C编辑程序大约有50条命令, 用以移动光标, 按页查看正文,  查找并
替换字符串等。如下表所示。

                  表1. Turbo C编辑程序命令
━━━┳━━━━━━━━━┳━━━━━━━━━━━━━
类别 ┃   功能           ┃       默认键
━━━╋━━━━━━━━━╋━━━━━━━━━━━━━
      ┃  字符左          ┃  Ctrl+S或Left
  基  ┃  字符右          ┃  Ctrl+D或Right
  本  ┃  字左            ┃  Ctrl+A
  光  ┃  字右            ┃  Ctrl+F
  标  ┃  上行            ┃  Ctrl+E或Up
  移  ┃  下行            ┃  Ctrl+X或Down
  动  ┃  上滚            ┃  Ctrl+W
  命  ┃  下滚            ┃  Ctrl+Z
  令  ┃  上一页          ┃  Ctrl+R或PgUp
      ┃  下一页          ┃  Ctrl+C或PgDn
━━━╋━━━━━━━━━╋━━━━━━━━━━━━━
  快  ┃  行头            ┃  Ctrl+QS或Home
  速  ┃  行尾            ┃  Ctrl+QD或End
  光  ┃  窗口头          ┃  Ctrl+QE
  标  ┃  窗口底          ┃  Ctrl+QX
  移  ┃  文件头          ┃  Ctrl+QR
  动  ┃  文件尾          ┃  Ctrl+QC
  命  ┃  块头            ┃  Ctrl+QB
  令  ┃  块尾            ┃  Ctrl+QK
      ┃  上次光标位置    ┃  Ctrl+QP
━━━╋━━━━━━━━━╋━━━━━━━━━━━━━
  输  ┃  插入模式        ┃  Ctrl+V或Ins
  入  ┃  插入行          ┃  Ctrl+N
  与  ┃  删除行          ┃  Ctrl+Y
  删  ┃  删除至行尾      ┃  Ctrl+QY
  除  ┃  删除光标左边字符┃  Ctrl+H或Backspace
  命  ┃  删除光标处字符  ┃  Ctrl+G或Del
  令  ┃  删除光标右边字符┃  Ctrl+T
━━━╋━━━━━━━━━╋━━━━━━━━━━━━━
      ┃  标记块首        ┃  Ctrl+KB
      ┃  标记块尾        ┃  Ctrl+KK
      ┃  标记单个字      ┃  Ctrl+KT
  块  ┃  复制块          ┃  Ctrl+KC
  命  ┃  删除块          ┃  Ctrl+KY
  令  ┃  块取消          ┃  Ctrl+KH
      ┃  块移动          ┃  Ctrl+KV
      ┃  读块            ┃  Ctrl+KR
      ┃  写块            ┃  Ctrl+KW
━━━╋━━━━━━━━━╋━━━━━━━━━━━━━
      ┃  异常结束操作    ┃  Ctrl+U或Ctrl+Break
      ┃  制表            ┃  Ctrl+L或Tab
  其  ┃  自动缩进        ┃  Ctrl+OI
      ┃  定界符配对      ┃  Ctrl+Q[或Ctrl+Q]
  它  ┃  查找            ┃  Ctrl+QF
      ┃  查找并替换      ┃  Ctrl+QA
      ┃  查找标记        ┃  Ctrl+QN
      ┃  退出编辑        ┃  Ctrl+KQ
━━━┻━━━━━━━━━┻━━━━━━━━━━━━━

    Turbo C 程序的调试

    一个程序设计好了以后, 通常会有一些错误, 查找和修改程序中的错误是令
人头痛的事。Turbo C集成开发环境提供了一调试装置,  使得这一个工作容易了
许多, 程序调试达到了编译和运行级。

    一、TC消息窗口

    使用TC最好的理由之一是它允许用户修改语法错误(编译时) 和评估编译器给
出的警告。TC将编译器和连接器发出的消息收集到一缓冲区中, 然后在消息窗口
中显示, 这样在访问源代码的同时, 还能一下看到这些消息。
    现将上面的HELLO.C制造一点语法错误, 将第一行包含语句的#去掉, 再去掉
第五行printf语句中的后引号。现在程序看上去是这样的:
     include
     main()
     {
          printf("Hello, world\n);
     }
按CTRL+F9重新编译之。编译窗口将显示有多少错误和警告: 应为两个错误, 0个
警告。
    当看见编译窗口中的Press anykey提示时, 按空格键, 消息窗口立刻被激活,
亮条出现在第一个错误或警告上, 这时编辑窗口中也会有一亮条--- 它标志着编
译器给出的错误或警告在源代码中的相应位置。
    这时可用光标键将消息窗口中的亮条上下移动, 注意到编辑窗口中的亮条也
随着跟踪源代码中错误发生的位置。如果将亮条置于"compile"上,  则编辑器显
示文件的最后位置。
    如果消息窗口太长看不见, 可用左、右光标水平滚动消息, 为了一次能够多
看点信息, 可按F5放大消息窗口。放大后, 编辑窗口不可见了, 因此不进行错误
跟踪。现在, 保持分屏模式。
    为了改正错误, 将消息窗口中的亮条置于第一个错误消息上, 回车, 光标移
到编辑窗口中错误产生处, 注意, 编辑器状态给出所选消息( 这在放大模式下是
有用的)改正之。(将第一行拿走的#重新写上)。
    当不只一个错误时, 可用两种方法来修改下一错误。
    第一种方法和前面一样, 按F6回到消息窗口选择想修改的下一条消息。
    第二种方法不用回到消息窗口, 只要按Alt+F8, 编译器就会将光标移至消息
窗口中列的下一个错误。按Alt+F7可移至前一个错误。
    这两种方法各有长短, 视情况而定。有时源代码中一个愚蠢的错误把编译弄
糊涂了, 产生好多消息, 这时选择修改第一条消息就使得其余的一些错误消息没
有什么意义了, 这种情况发生时, 使用方法一会方便些, 一修改完第一个错误之
后回到消息窗口, 再滚动到下一个有意义的消息上, 选择之。在别的情况下, 按
Alt+F8会方便得多。
    记住, Alt+F7和Alt+F8是热键, TC中无论何时均起作用。因此在消息窗口中
按Alt+F8得到的不是当前亮行消息, 而是下一个消息(按Enter选择当前消息)。
但如果没别的编译消息, Alt+F8就不起作用了。
    注: 可以如此法选择连接消息, 但它们不跟踪源文件。在修改语法错误的过
程当中, 经常需要增加、删除正文, 编辑器是记住的, 依然能正确定位错误位置。
没有必要记住行号和增加、删除的正文行。

    二、Turbo C集成调试器

    一旦修改好语法错误之后程序编译就没什么问题了, 但还是可能不按要求运
行, 因为可能有逻辑错误(运行错误)。这种错误跟踪就无助于发现错误位置了。
TC有一个集成调试器可以跟踪运行错误。通过调试器可以运行,  在断点处暂停,
检查变量的值, 甚至可以改变之, 以看程序会有什么反应。
　  Turbo C集成调试器是源程序级的调试器, 即用同你编写程序一样的" 语言"
来控制调试器。例如, 为了显示数组中的一个元素的值, 可告诉调试器显示这样
的表达式的值:
Ctrl+F4  Debug/Eavluate            计算表达式, 允许修改变量的值。
         Debug/Find Function       查找函数定义, 显示在编辑窗口中。 仅
                                   在调试时才有效。
Ctrl+F3  Debug/Call Stack          显示调用栈,  可显示任何函数的当前执
                                   行位置, 其方法是在调用栈中选择相应的
                                   函数名。仅在调试时有效。
         Debug/Source Debugging    控制是否允许调试: 置为On时,  集成调
                                       试器和单独调试器均可用 ;   置为
                                        Standalone时, 只能用单独调试器
                                        调试, 虽然还能在TC中运行; 置为
                                        None时, 在.EXE文件不置调试信息,
                                        两种调试均不能调试。
Ctrl+F4  Break/Watch/Add Watch          增加一监视表达式。
         Break/Watch/Delete Watch       删除一监视表达式。
         Break/Watch/Edit               编辑一监视表达式。
         Break/Watch/Remove All         删除所有监视表达式。
           Watches
Ctrl+F8  Break/Watch/Toggle             设置或清除光标所在行的断点。
           Breakpoint
         Break/Watch/Clear              删除程序中所有断点。
           Breakpoint
         Break/Watch/Next               显示下一断点
           Breakpoint
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

               表3. 调试器菜单命令及其热键
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  热键            菜单命令                           功能
───────────────────────────────────
  F5                                 在整屏和分屏之间放大缩小活动窗口。
Alt+F5                               将显示转到用户屏, 击任意键返回。
  F6                                 在编辑窗口与监视窗口或消息窗口间
                                     切换。
Alt+F6                               若编辑窗口是活动的,  转到最近一次
                                     装入编辑器的文件;  若下面窗口是活
                                     动的, 则在监视窗口和消息窗口间切换。
Ctrl+F9   Run/Run                    调试运行或不调试运行程序,  必要时
                                     编译、连接源文件, 若编译、 连接时
                                     Debug/Source Debuging和O/C/C/OBJ
                                     Debug Information为On, 则运行程序
                                     到断点或程序末尾。
          Project/Remove Messages    删除消息窗口中的内容。
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

    判断程序是否出错或者为什么出错是编程中最有挑战意义的一方面。这里建
义你进行预防性设计, 具体做法为:
    (1). 将代码写清楚点, 应作适当缩进, 使用文字说明和描述性的变量名。
    (2). 代码应简单, 把精力放在简单语句中的复杂表达式,  而不是一些复杂
语句。Turbo C的代码优化机制将大大提高代码的效率, 而且调试、阅读、 修改
起来容易。
    (3). 尽量用目的简单、好定义的函数构建程序。 这会便于编制调试程序和
分析结果, 而且阅读、修改起来也要容易一些。
    (4). 应尽量减少各个函数要求的数据和改变数据的元素个数。这也会便于
编制测试程序和分析结果; 同样便于阅读、修改程序。并且还限制了出错函数可
能造成的巨大混乱的牵涉面, 便得能在一个调试节中多运行函数几次。
    (5). 要留心编写程序中的公共函数, 或者说在其它程序中可再用的函数。
编写、调试一个一般性的函数通常要比编写、调试两个或更多的特殊函数要容易。



    Turbo C编译、连接和运行时的常见错误


    一、编译时的常见错误

    1. 数据类型错误。此类错误是初学者编程时的常见现象,  下面是一些要引
起注意的错误:
     (1) 所有变量和常量必须要加以说明。
     (2) 变量只能赋给相同类型的数据。
     (3) 对scanf()语句, 用户可能输入错误类型的数据项, 这将导致运行时出
错, 并报出错信息。为避免这样的错误出现, 你就提示用户输入正确类型的数据。
     (4) 在执行算术运算时要注意:
          a. 根据语法规则书写双精度数字。要写0.5, 而不是写.5; 要写1.0,
             而不是1。尽管C语言会自动地把整型转换成双精度型, 但书写双精
             度型是个好习惯。让C语言为你做强行转换这是一种效率不高的程序
             设计风格。 这有可能导致转换产生错误。
          b. 不要用0除。这是一个灾难性的错误, 它会导致程序失败,  不管C
             语言的什么版本, 都是如此, 执行除法运算要特别小心。
          c. 确保所有的双精度数(包括那些程序输入用的双精度数) 是在实数
             范围之内。
          d. 所有整数必须在整数允许的范围内。这适用于所有计算结果,  包
             括中间结果。

    2. 将函数后面的";"忘掉。此时错误提示色棒将停在该语句下的一行, 并显
示:
     Statement missing ; in function <函数名>

    3. 给宏指令如#include, #define等语句尾加了";"号。

    4. "{"和"}"、"("和")"、"/*"和"*/"不匹配。 引时色棒将位于错误所在的
行, 并提示出有关丢掉括号的信息。

    5. 没有用#include指令说明头文件,  错误信息提示有关该函数所使用的参
数未定义。

    6. 使用了Turbo C保留关键字作为标识符, 此时将提示定义了太多数据类型。

    7. 将定义变量语句放在了执行语句后面。此时会提示语法错误。

    8. 使用了未定义的变量, 此时屏幕显示:
        Undefined symbol '<变量名>' in function <函数名>

    9. 警告错误太多。忽略这些警告错误并不影响程序的执行和结果。编译时
当警告错误数目大于某一规定值时(缺省为100)便退出编译器,  这时应改变集成
开发环境Options/Compiler/Errors中的有关警告错误检查开关为off。

    10. 将关系符"=="误用作赋值号"="。此时屏幕显示:
        Lvalue required in function <函数名>

    二、连接时的常见错误

    1. 将Turbo C库函数名写错。这种情况下在连接时将会认为此函数是用户自
定义函数。此时屏幕显示:
       Undefined symbol '<函数名>' in <程序名>

    2. 多个文件连接时, 没有在"Project/Project name中指定项目文件 (.PRJ
文件), 此时出现找不到函数的错误。

    3. 子函数在说明和定义时类型不一致。

    4. 程序调用的子函数没有定义。

    三、运行时的常见错误

    1. 路径名错误。在MS-DOS中, 斜杠(\)表示一个目录名; 而在Turbo C 中斜
杠是个某个字符串的一个转义字符, 这样, 在用Turbo C 字符串给出一个路径名
时应考虑"\"的转义的作用。例如, 有这样一条语句:
          file=fopen("c:\new\tbc.dat", "rb");
目的是打开C盘中NEW目录中的TBC.DAT文件, 但做不到。这里"\"后面紧接的分别
是"n"及"t", "\n"及"\t"将被分别编译为换行及tab字符, DOS将认为它是不正确
的文件名而拒绝接受, 因为文件名中不能和换行或tab字符。正确的写法应为:
          file=fopen("c:\\new\\tbc.dat", "rb");

    2. 格式化输入输出时, 规定的类型与变量本身的类型不一致。例如:
          float l;
          printf("%c", l);

    3. scanf()函数中将变量地址写成变量。例如:
          int l;
          scanf("%d", l);

    4. 循环语句中, 循环控制变量在每次循环未进行修改,  使循环成为无限循
环。

    5. switch语句中没有使用break语句。

    6. 将赋值号"="误用作关系符"=="。

    7. 多层条件语句的if和else不配对。

    8. 用动态内存分配函数malloc()或calloc()分配的内存区使用完之后,  未
用free()函数释放, 会导致函数前几次调用正常, 而后面调用时发生死机现象,
不能返回操作系统。其原因是因为没用空间可供分配, 而占用了操作系统在内存
中的某些空间。

    9. 使用了动态分配内存不成功的指针, 造成系统破坏。


    10. 在对文件操作时, 没有在使用完及时关闭打开的文件。