C语言基础教程（三）输入输出函数及控制流程语句

    本节主要介绍Turbo C2.0标准输入输出函数和文件的输入输出函数。通过本
节的学习可以使读者掌握Turbo C2.0的屏幕输出、键盘输入输出以及磁盘文件的
读写函数, 并能开始进行一些简单的程序的编写。
    控制流程语句主要包括: 条件语句、循环语句和开关语句。
 
 

1.1  标准输入输出函数 

    1.1.1 格式化输入输出函数
    Turbo C2.0 标准库提供了两个控制台格式化输入、 输出函数printf( ) 和
scanf(), 这两个函数可以在标准输入输出设备上以各种不同的格式读写数据。
printf()函数用来向标准输出设备(屏幕)写数据; scanf() 函数用来从标准输入
设备(键盘)上读数据。下面详细介绍这两个函数的用法。
    一、printf()函数
    printf()函数是格式化输出函数, 一般用于向标准输出设备按规定格式输出
信息。在编写程序时经常会用到此函数。printf()函数的调用格式为:
      printf(“<格式化字符串>”, <参量表>);
    其中格式化字符串包括两部分内容: 一部分是正常字符,  这些字符将按原
样输出; 另一部分是格式化规定字符, 以”%”开始, 后跟一个或几个规定字符,
用来确定输出内容格式。
    参量表是需要输出的一系列参数, 其个数必须与格式化字符串所说明的输出
参数个数一样多, 各参数之间用”,”分开, 且顺序一一对应,  否则将会出现意想
不到的错误。

    1. 格式化规定符
    Turbo C2.0提供的格式化规定符如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━
   符号                  作用
──────────────────────────
    %d              十进制有符号整数
    %u              十进制无符号整数
    %f              浮点数
    %s              字符串
    %c              单个字符
    %p              指针的值
    %e              指数形式的浮点数
    %x, %X          无符号以十六进制表示的整数
    %0              无符号以八进制表示的整数
    %g              自动选择合适的表示法
━━━━━━━━━━━━━━━━━━━━━━━━━━
    说明:
    (1). 可以在”%”和字母之间插进数字表示最大场宽。
     例如:  %3d   表示输出3位整型数, 不够3位右对齐。
            %9.2f 表示输出场宽为9的浮点数, 其中小数位为2, 整数位为6,
                  小数点占一位, 不够9位右对齐。
            %8s   表示输出8个字符的字符串, 不够8个字符右对齐。
    如果字符串的长度、或整型数位数超过说明的场宽, 将按其实际长度输出。
但对浮点数, 若整数部分位数超过了说明的整数位宽度, 将按实际整数位输出;
若小数部分位数超过了说明的小数位宽度, 则按说明的宽度以四舍五入输出。
    另外, 若想在输出值前加一些0, 就应在场宽项前加个0。
    例如:   %04d  表示在输出一个小于4位的数值时, 将在前面补0使其总宽度
为4位。
    如果用浮点数表示字符或整型量的输出格式, 小数点后的数字代表最大宽度,
小数点前的数字代表最小宽度。
    例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9,  则
第9个字符以后的内容将被删除。
    (2). 可以在”%”和字母之间加小写字母l, 表示输出的是长型数。
    例如:   %ld   表示输出long整数
            %lf   表示输出double浮点数
    (3). 可以控制输出左对齐或右对齐, 即在”%”和字母之间加入一个”-” 号可
说明输出为左对齐, 否则为右对齐。
    例如:   %-7d  表示输出7位整数左对齐
            %-10s 表示输出10个字符左对齐

    2. 一些特殊规定字符
━━━━━━━━━━━━━━━━━━━━━━━━━━
    字符                           作用
──────────────────────────
     n                   换行
     f                   清屏并换页
     r                   回车
     t                   Tab符
     xhh                 表示一个ASCII码用16进表示,
                          其中hh是1到2个16进制数
━━━━━━━━━━━━━━━━━━━━━━━━━━
    由本节所学的printf()函数, 并结合上一节学习的数据类型, 编制下面的程
序, 以加深对Turbo C2.0数据类型的了解。
    例1
     #include<stdio.h>
     #include<string.h>
     int main()
     {
          char c, s[20], *p;
          int a=1234, *i;
          float f=3.141592653589;
          double x=0.12345678987654321;
          p=”How do you do”;
          strcpy(s, “Hello, Comrade”);
          *i=12;
          c=’x41′;
          printf(“a=%dn”, a);     /*结果输出十进制整数a=1234*/
          printf(“a=%6dn”, a);    /*结果输出6位十进制数a=  1234*/
          printf(“a=%06dn”, a);   /*结果输出6位十进制数a=001234*/
          printf(“a=%2dn”, a);    /*a超过2位, 按实际值输出a=1234*/
          printf(“*i=%4dn”, *i);  /*输出4位十进制整数*i=  12*/
          printf(“*i=%-4dn”, *i); /*输出左对齐4位十进制整数*i=12*/
          printf(“i=%pn”, i);     /*输出地址i=06E4*/
          printf(“f=%fn”, f);     /*输出浮点数f=3.141593*/
          printf(“f=6.4fn”, f);   /*输出6位其中小数点后4位的浮点数
                                      f=3.1416*/
          printf(“x=%lfn”, x);    /*输出长浮点数x=0.123457*/
          printf(“x=%18.16lfn”, x);/*输出18位其中小数点后16位的长浮点
                                      数x=0.1234567898765432*/
          printf(“c=%cn”, c);     /*输出字符c=A*/
          printf(“c=%xn”, c);     /*输出字符的ASCII码值c=41*/
          printf(“s[]=%sn”, s);   /*输出数组字符串s[]=Hello, Comrade*/
          printf(“s[]=%6.9sn”, s);/*输出最多9个字符的字符串s[]=Hello,
                                     Co*/
          printf(“s=%pn”, s);     /*输出数组字符串首字符地址s=FFBE*/
          printf(“*p=%sn”, p);    /* 输出指针字符串p=How do you do*/
          printf(“p=%pn”, p);     /*输出指针的值p=0194*/
          getch();
          retunr 0;
     }
    上面结果中的地址值在不同计算机上可能不同。
    例1.中第一条语句#include<stdio.h>的含义是调用另一个文件stdio.h, 这
是一个头文件, 其中包括全部标准输入输出库函数的数据类型定义和函数说明。
Turbo C2.0对每个库函数便用的变量及函数类型都已作了定义与说明, 放在相应
头文件”*.h”中, 用户用到这些函数时必须要用#include<*.h>或#include”*. h”
语句调用相应的头文件, 以供连接。若没有用此语句说明, 则连接时将会出现错
误。

    二、scanf()函数
    scanf()函数是格式化输入函数, 它从标准输入设备(键盘) 读取输入的信息。
其调用格式为:
      scanf(“<格式化字符串>”, <地址表>);
    格式化字符串包括以下三类不同的字符;
    1. 格式化说明符: 格式化说明符与printf()函数中的格式说明符基本相同。
    2. 空白字符: 空白字符会使scanf()函数在读操作中略去输入中的一个或多
个空白字符。
    3. 非空白字符: 一个非空白字符会使scanf()函数在读入时剔除掉与这个非
空白字符相同的字符。
    地址表是需要读入的所有变量的地址, 而不是变量本身。这与printf()函数
完全不同, 要特别注意。各个变量的地址之间同”,”分开。
    例2:
     main()
     {
          int i, j;
          printf(“i, j=?n”);
          scanf(“%d, %d”, &i, &j);
     }

    上例中的scanf()函数先读一个整型数, 然后把接着输入的逗号剔除掉,  最
后读入另一个整型数。如果”,”这一特定字符没有找到, scanf()函数就终止。若
参数之间的分隔符为空格, 则参数之间必须输入一个或多个空格。
    说明:
    (1). 对于字符串数组或字符串指针变量,  由于数组名和指针变量名本身就
是地址, 因此使用scanf()函数时, 不需要在它们前面加上”&”操作符。
    例3
      mian()
     {
          char *p, str[20];
          scanf(“%s”, p);          /*从健盘输入字符串*/
          scanf(“%s”, str);
          printf(“%sn”, p);       /*向屏幕输出字符串*/
          printf(“%sn”, str);
     }

    (2). 可以在格式化字符串中的”%”各格式化规定符之间加入一个整数, 表示
任何读操作中的最大位数。
    如例3中若规定只能输入10字符给字符串指针p, 则第一条scanf() 函数语句
变为
          scanf(“%10s”, p);
    程序运行时一旦输入字符个数大于10,  p就不再继续读入, 而后面的一个读
入函数即scanf(“%s”, str)就会从第11个字符开始读入。
    实际使用scanf()函数时存在一个问题, 下面举例进行说明:
    当使用多个scanf()函数连续给多个字符变量输入时, 例如:
     main()
     {
          char c1, c2;
          scanf(“%c”, &c1);
          scanf(“%c”, &c2);
          printf(“c1 is %c, c2 is %c”, c21, c2);
     }

    运行该程序, 输入一个字符A后回车 (要完成输入必须回车), 在执行scanf
(“%c”, &c1)时, 给变量c1赋值”A”, 但回车符仍然留在缓冲区内, 执行输入语句
scanf(“%c”, &c2)时, 变量c2输出的是一空行, 如果输入AB后回车, 那么输出结
果为: c1 is A, c2 is B。
    要解决以上问题, 可以在输入函数前加入清除函数fflush()( 这个函数的使
用方法将在本节最后讲述)。修改以上程序变成:
     #include<stdio.h>
     main()
     {
          char c1, c2;
          scanf(“%c”, &c1);
          fflush(stdin);
          scanf(“%c”, &c2);
          printf(“c1 is %c, c2 is %c”, c1, c2);
     }

    1.1.2 非格式化输入输出函数
    非格式化输入输出函数可以由上面讲述的标准格式化输入输出函数代替, 但
这些函数编译后代码少, 相对占用内存也小, 从而提高了速度, 同时使用也比较
方便。下面分别进行介绍。
    一、puts()和gets()函数
    1. puts()函数
    puts()函数用来向标准输出设备(屏幕)写字符串并换行, 其调用格式为:
     puts(s);
    其中s为字符串变量(字符串数组名或字符串指针)。
    puts()函数的作用与语printf(“%sn”, s)相同。
    例4:
     main()
     {
          char s[20], *f;                 /*定义字符串数组和指针变量*/
          strcpy(s, “Hello! Turbo C2.0”); /*字符串数组变量赋值*/
          f=”Thank you”;                  /*字符串指针变量赋值*/
          puts(s);
          puts(f);
     }

    说明:
    (1). puts()函数只能输出字符串, 不能输出数值或进行格式变换。
    (2). 可以将字符串直接写入puts()函数中。如:
          puts(“Hello, Turbo C2.0”);

    2. gets()函数
    gets()函数用来从标准输入设备(键盘)读取字符串直到回车结束, 但回车符
不属于这个字符串。其调用格式为:
    gets(s);
    其中s为字符串变量(字符串数组名或字符串指针)。
    gets(s)函数与scanf(“%s”, &s)相似, 但不完全相同, 使用scanf(“%s”, &s)
函数输入字符串时存在一个问题, 就是如果输入了空格会认为输入字符串结束,
空格后的字符将作为下一个输入项处理, 但gets() 函数将接收输入的整个字符
串直到回车为止。
    例5
     main()
     {
          char s[20], *f;
          printf(“What’s your name?n”);
          gets(s);                      /*等待输入字符串直到回车结束*/
          puts(s);                      /*将输入的字符串输出*/
          puts(“How old are you?”);
          gets(f);
          puts(f);
     }
    说明:
    (1). gets(s)函数中的变量s为一字符串。如果为单个字符,  编译连接不会
有错误, 但运行后会出现”Null pointer asignmemt”的错误。

    二、putchar()、getch()、getche()和getchar()函数
    1. putchar()函数
    putchar()函数是向标准输出设备输出一个字符, 其调用格式为:
     putchar(ch);
    其中ch为一个字符变量或常量。
    putchar()函数的作用等同于printf(“%c”, ch);
    例6:
     #include<stdio.h>
     main()
     {
          char c:             /*定义字符变量*/
          c=’B’;              /*给字符变量赋值*/
          putchar(c);         /*输出该字符*/
          putchar(‘x42’);    /*输出字母B*/
          putchar(0x42);      /*直接用ASCII码值输出字母B*/
     }
    从本例中的连续四个字符输出函数语句可以分清字符变量的不同赋值方法。
    2. getch()、getche()和getchar()函数
    (1) getch()和getche()函数
    这两个函数都是从键盘上读入一个字符。其调用格式为:
     getch();
     getche();
    两者的区别是: getch()函数不将读入的字符回显在显示屏幕上, 而getche()
函数却将读入的字符回显到显示屏幕上。
    例7:
     #include<stdio.h>
     main()
     {
          char c, ch;
          c=getch();     /*从键盘上读入一个字符不回显送给字符变量c*/
          putchar(c);    /*输出该字符*/
          ch=getche();   /*从键盘上带回显的读入一个字符送给字符变量ch*/
          putchar(ch);
     }
    利用回显和不回显的特点, 这两个函数经常用于交互输入的过程中完成暂停
等功能。

    例8:
     #include<stdio.h>
     main()
     {
          char c, s[20];
          printf(“Name:”);
          gets(s);
          printf(“Press any key to confinue…”);
          getch();  /*等待输入任一键*/
     }
 
    (2) getchar()函数
    getchar()函数也是从键盘上读入一个字符, 并带回显。它与前面两个函数
的区别在于: getchar()函数等待输入直到按回车才结束,  回车前的所有输入字
符都会逐个显示在屏幕上。但只有第一个字符作为函数的返回值。
    getchar()函数的调用格式为:
     getchar();
    例9:
     #include<stdio.h>
     main()
     {
          char c;
          c=getchar();   /*从键盘读入字符直到回车结束*/
          putchar(c);    /*显示输入的第一个字符*/
          getch();       /*等待按任一健*/
     }

    2. fclose()函数
    fclose()函数用来关闭一个由fopen()函数打开的文件 , 其调用格式为:
      int fclose(FILE *stream);
    该函数返回一个整型数。当文件关闭成功时, 返回0,　否则返回一个非零值。
可以根据函数的返回值判断文件是否关闭成功。
    例10:
     #iclude<stdio.h>
     main()
     {
          FILE *fp;                /*定义一个文件指针*/
          int i;
          fp=fopen(“CLIB”, “rb”);  /*打开当前目录名为CLIB的文件只读*/
          if(fp==NULL)             /*判断文件是否打开成功*/
             puts(“File open error”);/*提示打开不成功*/
          i=fclose(fp);            /*关闭打开的文件*/
          if(i==0)                 /*判断文件是否关闭成功*/
            printf(“O,K”);         /*提示关闭成功*/
          else
            puts(“File close error”);/*提示关闭不成功*/
     }

    二、有关文件操作的函数
    本节所讲的文件读写函数均是指顺序读写, 即读写了一条信息后, 指针自动
加1。下面分别介绍写操作函数和读操作函数。

    1. 文件的顺序写函数
    fprintf()、fputs()和fputc()函数
    函数fprintf()、fputs()和fputc()均为文件的顺序写操作函数,  其调用格
式如下:
    int fprintf(FILE *stream, char *format, <variable-list>);
    int fputs(char *string, FILE *steam);
    int fputc(int ch, FILE *steam);
    上述三个函数的返回值均为整型量。fprintf() 函数的返回值为实际写入文
件中的字罕个数(字节数)。如果写错误, 则返回一个负数, fputs()函数返回0时
表明将string指针所指的字符串写入文件中的操作成功, 返回非0时,  表明写操
作失败。fputc()函数返回一个向文件所写字符的值, 此时写操作成功,  否则返
回EOF(文件结束结束其值为-1, 在stdio.h中定义)表示写操作错误。
     fprintf( ) 函数中格式化的规定与printf( ) 函数相同,   所不同的只是
fprintf()函数是向文件中写入。而printf()是向屏幕输出。
    下面介绍一个例子, 运行后产后一个test.dat的文件。
    例11:
     #include<stdio.h>
     main()
     {
          char *s=”That’s good news”);  /*定义字符串指针并初始化*/
          int i=617;                    /*定义整型变量并初始化*/
          FILE *fp;                     /*定义文件指针*/
          fp=fopne(“test.dat”, “w”);    /*建立一个文字文件只写*/
          fputs(“Your score of TOEFLis”, fp);/*向所建文件写入一串字符*/
          fputc(‘:’, fp);               /*向所建文件写冒号:*/
          fprintf(fp, “%dn”, i);       /*向所建文件写一整型数*/
          fprintf(fp, “%s”, s);         /*向所建文件写一字符串*/
          fclose(fp);                   /*关闭文件*/
     }
    用DOS的TYPE命令显示TEST.DAT的内容如下所示:
    屏幕显示
      Your score of TOEFL is: 617
      That’s good news

    2. 文件的顺序读操作函数
    fscanf()、fgets()和fgetc()函数
    函数fscanf()、fgets()和fgetc()均为文件的顺序读操作函数, 其调用格式
如下:
     int fscanf(FILE *stream, char *format, <address-list>);
     char fgets(char *string, int n, FILE *steam);
     int fgetc(FILE *steam);
    fscanf()函数的用法与scanf()函数相似,   只是它是从文件中读到信息。
fscanf()函数的返回值为EOF(即-1), 表明读错误, 否则读数据成功。fgets()函
数从文件中读取至多n-1个字符(n用来指定字符数), 并把它们放入string指向的
字符串中, 在读入之后自动向字符串未尾加一个空字符, 读成功返回string指针,
失败返回一个空指针。fgetc()函数返回文件当前位置的一个字符,  读错误时返
回EOF。
    下面程序读取例11产生的test.dat文件, 并将读出的结果显示在屏幕上。
    例12
     #include<stdio.h>
     main()
     {
          char *s, m[20];
          int i;
          FILE  *fp;
          fp=fopen(“test.dat”, “r”);    /*打开文字文件只读*/
          fgets(s, 24, fp);             /*从文件中读取23个字符*/
          printf(“%s”, s);              /*输出所读的字符串*/
          fscanf(fp, “%d”, &i);         /*读取整型数*/
          printf(“%d”, i);              /*输出所读整型数*/
          putchar(fgetc(fp));           /*读取一个字符同时输出*/
          fgets(m, 17, fp);             /*读取16个字符*/
          puts(m);                      /*输出所读字符串*/
          fclose(fp);                   /*关闭文件*/
          getch();                      /*等待任一键*/
     }
    运行后屏幕显示:
    Your score of TOEFL is: 617
    That’s good news
    如果将上例中fscanf(fp, “%d”, &i)改为fscanf(fp, “%s”, m),  再将其后
的输出语句改为printf(“%s”, m), 则可得出同样的结果。由此可见Turbo C2. 0
中只要是读文字文件, 则不论是字符还是数字都将按其ASCII值处理。 另外还要
说明的一点就是fscanf()函数读到空白符时, 便自动结束, 在使用时要特别注意。

    3. 文件的随机读写
    有时用户想直接读取文件中间某处的信息, 若用文件的顺序读写必须从文件
头开始直到要求的文件位置再读, 这显然不方便。Turbo C2.0提供了一组文件的
随机读写函数, 即可以将文件位置指针定位在所要求读写的地方直接读写。
    文件的随机读写函数如下:
    int fseek (FILE *stream, long offset, int fromwhere);
    int fread(void *buf, int size, int count, FILE *stream);
    int fwrite(void *buf, int size, int count, FILE *stream);
    long ftell(FILE *stream);
    fseek()函数的作用是将文件的位置指针设置到从fromwhere开始的第offset
字节的位置上, 其中fromwhere是下列几个宏定义之一:
    文件位置指针起始计算位置fromwhere
━━━━━━━━━━━━━━━━━━━━━━━━━━━
    符号常数        数值           含义
───────────────────────────
    SEEK_SET          0        从文件开头
    SEEK_CUR          1        从文件指针的现行位置
    SEEK_END          2        从文件末尾
━━━━━━━━━━━━━━━━━━━━━━━━━━━
    offset是指文件位置指针从指定开始位置(fromwhere指出的位置)跳过的字
节数。它是一个长整型量, 以支持大于64K字节的文件。fseek()函数一般用于对
二进制文件进行操作。
    当fseek()函数返回0时表明操作成功, 返回非0表示失败。
    下面程序从二进制文件test_b.dat中读取第8个字节。
    例13:
     #include<stdio.h>
     main()
     {
          FILE *fp;
          if((fp=fopen(“test_b.dat”, “rb”))==NULL)
            {
              printf(“Can’t open file”);
              exit(1);
            }
          fseek(fp, 8. 1, SEEK_SET);
          fgetc(fp);
          fclose(fp);
     }
    fread()函数是从文件中读count个字段, 每个字段长度为size个字节, 并把
它们存放到buf指针所指的缓冲器中。
    fwrite()函数是把buf指针所指的缓冲器中, 长度为size个字节的count个字
段写到stream指向的文件中去。
    随着读和写字节数的增大, 文件位置指示器也增大, 读多少个字节, 文件位
置指示器相应也跳过多少个字节。读写完毕函数返回所读和所写的字段个数。
    ftell()函数返回文件位置指示器的当前值,  这个值是指示器从文件头开始
算起的字节数, 返回的数为长整型数, 当返回-1时, 表明出现错误。

    下面程序把一个浮点数组以二进制方式写入文件test_b.dat中。
    例14:
     #include <stdio.h>
     main()
     {
          float f[6]={3.2, -4.34, 25.04, 0.1, 50.56, 80.5};
                         /*定义浮点数组并初始化*/
          int i;
          FILE *fp;
          fp=fopen(“test_b.dat”, “wb”); /*创建一个二进制文件只写*/
          fwrite(f, sizeof(float), 6, fp);/*将6个浮点数写入文件中*/
          fclose(fp);                   /*关闭文件*/
     }
    下面例子从test_b.dat文件中读100个整型数, 并把它们放到dat数组中。
    例15:
     #include <stdio.h>
     main()
     {
          FILE *fp;
          int dat[100];
          fp=fopen(“test_b.dat”, “rb”);/*打开一个二进制文件只读*/
          if(fread(dat, sizeof(int), 100, fp)!=100)
                                        /*判断是否读了100个数*/
            {
               if(feof(fp))
                 printf(“End of file”); /*不到100个数文件结束*/
               else
                 printf(“Read error”);  /*读数错误*/
          fclose(fp);                   /*关闭文件*/
     }
    注意:
    当用标准文件函数对文件进行读写操作时, 首先将所读写的内容放进缓冲区,
即写函数只对输出缓冲区进行操作, 读函数只对输入缓冲区进行操作。例如向一
个文件写入内容, 所写的内容将首先放在输出缓冲区中, 直到输出缓冲区存满或
使用fclose()函数关闭文件时, 缓冲区的内容才会写入文件中。若无fclose()
函数, 则不会向文件中存入所写的内容或写入的文件内容不全。有一个对缓冲区
进行刷新的函数, 即fflush(), 其调用格式为:
    int fflush(FILE *stream);
    该函数将输出缓冲区的内容实际写入文件中, 而将输入缓冲区的内容清除掉。

    4. feof()和rewind()函数
    这两个函数的调用格式为:
     int feof(FILE *stream);
     int rewind(FILE *stream);
    feof()函数检测文件位置指示器是否到达了文件结尾,  若是则返回一个非0
值, 否则返回0。这个函数对二进制文件操作特别有用, 因为二进制文件中,  文
件结尾标志EOF也是一个合法的二进制数,  只简单的检查读入字符的值来判断文
件是否结束是不行的。如果那样的话, 可能会造成文件未结尾而被认为结尾, 所
以就必须有feof()函数。
    下面的这条语句是常用的判断文件是否结束的方法。
     while(!feof(fp))
        fgetc(fp);
    while为循环语句, 将在下面介绍。
    rewind()函数用于把文件位置指示器移到文件的起点处, 成功时返回0,  否
则, 返回非0值。
 

    1.2.2  非标准文件函数
    这类函数最早用于UNIX操作系统, ANSI标准未定义,   但有时也经常用到,
DOS 3.0以上版本支持这些函数。它们的头文件为io.h。
    一、文件的打开和关闭
    1. open()函数
    open()函数的作用是打开文件, 其调用格式为:
     int open(char *filename, int access);
    该函数表示按access的要求打开名为filename的文件, 返回值为文件描述字,
其中access有两部分内容: 基本模式和修饰符, 两者用” “(“或”)方式连接。修
饰符可以有多个, 但基本模式只能有一个。access的规定如表3-2。
               表3-2  access的规定
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
基本模式    含义    修饰符         含  义
────────────────────────────
O_RDONLY    只读   O_APPEND   文件指针指向末尾
O_WRONLY    只写   O_CREAT    文件不存在时创建文件,
                              属性按基本模式属性
O_RDWR      读写   O_TRUNC    若文件存在, 将其长度
                              缩为0, 属性不变
                   O_BINARY   打开一个二进制文件
                   O_TEXT     打开一个文字文件
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    open()函数打开成功, 返回值就是文件描述字的值(非负值), 否则返回-1。

    2. close()函数
    close()函数的作用是关闭由open()函数打开的文件, 其调用格式为:
     int close(int handle);
    该函数关闭文件描述字handle相连的文件。

    二、读写函数
    1. read()函数
    read()函数的调用格式为:
     int read(int handle, void *buf, int count);
    read()函数从handle(文件描述字)相连的文件中, 读取count个字节放到buf
所指的缓冲区中, 返回值为实际所读字节数, 返回-1表示出错。返回0 表示文件
结束。

    2. write()函数
    write()函数的调用格式为:
     int write(int handle, void *buf, int count);
    write()函数把count个字节从buf指向的缓冲区写入与handle相连的文件中,
返回值为实际写入的字节数。
 
    三、随机定位函数
    1. lseek()函数
    lseek()函数的调用格式为:
     int lseek(int handle, long offset, int fromwhere);
    该函数对与handle相连的文件位置指针进行定位, 功能和用法与fseek() 函
数相同。

    2. tell()函数
    tell()函数的调用格式为:
     long tell(int handle);
    该函数返回与handle相连的文件现生位置指针, 功能和用法与ftell()相同。

1.3 控制流程语句

    Turbo C2.0提供了丰富、灵活的控制流程语句, 主要有:条件语句、循环语
句和开关语句。下面将对这些语句作详细介绍。
 

    1.3.1  条件语句
    象其它语言一样Turbo C2.0也提供条件语句。在Turbo C2.0中条件语句的一
般形式为:
    if(表达式)
       语句1;
    else
       语句2;
    上述结构表示: 如果表达式的值为非0(TURE)即真, 则执行语句1, 执行完语
句1从语句2后开始继续向下执行; 如果表达式的值为0(FALSE)即假, 则跳过语句
1而执行语句2。所谓表达式是指关系表达式和逻辑表达式的结合式, 关于表达式
前面已作过介绍, 这是不再重复。
    注意:
    1. 条件执行语句中”else 语句2;”部分是选择项, 可以缺省, 此时条件语句
变成:
      if(表达式)  语句1;
    表示若表达式的值为非0则执行语句1 , 否则跳过语句1继续执行。
    2. 如果语句1或语句2有多于一条语句要执行时, 必须使用”{“和”}” 把这些
语句包括在其中, 此时条件语句形式为:
      if(表达式)
      {
        语句体1;
      }
      else
      {
          语句体2;
      }
    3. 条件语句可以嵌套, 这种情况经常碰到, 但条件嵌套语句容易出错,  其
原因主要是不知道哪个if对应哪个else。
    例如:
      if(x>20||x<-10)
      if(y<=100&&y>x)
          printf(“Good”);
      else
          printf(“Bad”);
    对于上述情况, Turbo C2.0规定: else语句与最近的一个if语句匹配, 上例
中的else与if(y<=100&&y>x)相匹配。为了使else与if(x>20||x<-10)相匹配, 必
须用花括号。如下所示:
      if(x>20||x<-10)
      {
          if(y<=100&&y>x)
            printf(“Good”);
       }
       else
          printf(“Bad”);
    4. 可用阶梯式if-else-if结构。
    阶梯式结构的一般形式为:
      if(表达式1)
         语句1;
      else if(表达式2)
        语句2;
      else if(表达式3)
        语句3;
          .
          .
          .
      else
        语句n;
    这种结构是从上到下逐个对条件进行判断, 一旦发现条件满点足就执行与它
有关的语句, 并跳过其它剩余阶梯; 若没有一个条件满足, 则执行最后一个else
语句n。最后这个else常起着”缺省条件”的作用。
    同样, 如果每一个条件中有多于一条语句要执行时, 必须使用”{“和”}”把这
些语句包括在其中。

    1.3.2 循环语句
    Turbo C2.0提供三种基本的循环语句: for语句、while语句和do-while语句。
 
    1.3.2.1  for循环
    for循环是开界的。它的一般形式为:
     for(<初始化>; <条件表过式>; <增量>)
          语句;
    初始化总是一个赋值语句, 它用来给循环控制变量赋初值; 条件表达式是一
个关系表达式, 它决定什么时候退出循环; 增量定义循环控制变量每循环一次后
按什么方式变化。这三个部分之间用”;”分开。
    例如:
     for(i=1; i<=10; i++)
          语句;
    上例中先给i赋初值1, 判断i是否小于等于10, 若是则执行语句,  之后值增
加1。再重新判断, 直到条件为假, 即i>10时, 结束循环。
    注意:
    1. for循环中语句可以为语句体, 但要用”{“和”}”将参加循环的语句括起来。
    2. for循环中的”初始化”、”条件表达式”和”增量”都是选择项, 即可以缺省,
但”;”不能缺省。省略了初始化, 表示不对循环控制变量赋初值。 省略了条件
表达式, 则不做其它处理时便成为死循环。省略了增量, 则不对循环控制变量进
行操作, 这时可在语句体中加入修改循环控制变量的语句。
    3. for循环可以有多层嵌套。
    例16:
     main()
     {
          int i, j, k;
          printf(“i j kn”);
          for (i=0; i<2; i++)
            for(j=0; j<2; j++)
               for(k=0; k<2; k++)
                  printf(%d %d %dn”, i, j, k);
     }
    输出结果为:
     i  j  k
     0  0  0
     0  0  1
     0  1  0
     0  1  1
     1  0  0
     1  0  1
     1  1  0
     1  1  1

    1.3.2.2 while循环
    while循环的一般形式为:
      while(条件)
          语句;
    while循环表示当条件为真时, 便执行语句。直到条件为假才结束循环。并
继续执行循环程序外的后续语句。
    例17:
     #include<stdio.h>
     main()
     {
          char c;
          c=’’;             /*初始化c*/
          while(c!=’X0D’)    /*回车结束循环*/
            c=getche();       /*带回显的从键盘接收字符*/
     }
    上例中, while循环是以检查c是否为回车符开始, 因其事先被初始化为空,
所以条件为真, 进入循环等待键盘输入字符; 一旦输入回车, 则c=’X0D’, 条件
为假, 循环便告结束。
    与for循环一样, while循环总是在循环的头部检验条件, 这就意味着循环可
能什么也不执行就退出。
    注意:
    1. 在while循环体内也允许空语句。
    例如:
     while((c=getche())!=’X0D’);
    这个循环直到键入回车为止。
    2. 可以有多层循环嵌套。
    3. 语句可以是语句体, 此时必须用”{“和”}”括起来。
    例18:
     #include<stdio.h>
     main()
     {
          char c, fname[13];
          FILE *fp;                /*定义文件指针*/
          printf(“File name:”);    /*提示输入文件名*/
          scanf(“%s”, fname);      /*等待输入文件名*/
          fp=fopen(fname, “r”);    /*打开文件只读*/
          while((c=fgetc(fp)!=EOF) /*读取一个字符并判断是否到文件结束*/
               putchar(c);         /*文件未结束时显示该字符*/

     }

    1.3.2.3 do-while 循环
    do-while 循环的一般格式为:
       do
           语句;
       while(条件);
    这个循环与while循环的不同在于: 它先执行循环中的语句,  然后再判断条
件是否为真, 如果为真则继续循环; 如果为假, 则终止循环。因此, do-while循
环至少要执行一次循环语句。
    同样当有许多语句参加循环时, 要用”{“和”}”把它们括起来。

    1.3.3 开关语句
    在编写程序时, 经常会碰到按不同情况分转的多路问题,  这时可用嵌套if
-else-fi语句来实现, 但if-else-if语句使用不方便, 并且容易出错。对这种情
况, Turbo C2.0提供了一个开关语句。开关语句格式为:
          switch(变量)
          {
               case 常量1:
                    语句1或空;
               case 常量2:
                    语句2或空;
                    .
                    .
                    .
               case 常量n;
                    语句n或空;
               default:
                    语句n+1或空;
          }
    执行switch开关语句时, 将变量逐个与case后的常量进行比较, 若与其中一
个相等, 则执行该常量下的语句, 若不与任何一个常量相等, 则执行default 后
面的语句。
    注意:
    1. switch中变量可以是数值, 也可以是字符。
    2. 可以省略一些case和default。
    3. 每个case或default后的语句可以是语句体, 但不需要使用”{“和”}”括起
来。
    下例的switch中变量为整数型。
    例19:
     main()
     {
          int test;
          for(test=0; test<=10; test++)
          {
               switch(test)   /*变量为整型数的开关语句*/
               {
                    case 1:
                         printf(“%dn”, test);
                         break;    /*退出开关语句*/
                    case 2:
                         printf(“%dn”, test);
                         break;
                    case 3:
                         printf(“%dn”, test);
                         break;
                    default:
                         puts(“Error”);
                         break;
               }
          }
     }
    下例的switch中变量为字符型。
    例20:
     #include<stdio.h>
     main()
     {
          char c;
          while(c!=27)                  /*循环直到按Esc键结束*/
          {
               c=getch();               /*从键盘不回显接收一个字符*/
               switch(c)
               {
                    case ‘A’:           /*接收的字符为’A’*/
                         putchar(c);
                         break;         /*退出开关语句*/
                    case ‘B’:
                         putchar(c);
                         break;
                    default:            /*接收的字符非’A’和’B’*/
                         puts(“Error”);
                         break;
               }
          }
     }

    1.3.4 break、continue和goto语句

    1.3.4.1 break语句
    break语句通常用在循环语句和开关语句中。当break用于开关语句switch中
时, 可使程序跳出switch而执行switch以后的语句; 如果没有break语句,  则将
成为一个死循环而无法退出。break在switch 中的用法已在前面介绍开关语句时
的例子中碰到, 这里不再举例。
    当break语句用于do-while、for、while循环语句中时,  可使程序终止循环
而执行循环后面的语句, 通常break语句总是与if语句联在一起。 即满足条件时
便跳出循环。
    例19:
     main()
     {
          int i=0;
          char c;
          while(1)                 /*设置循环*/
          {
               c=’’;             /*变量赋初值*/
               while(c!=13&&c!=27) /*键盘接收字符直到按回车或Esc键*/
               {
                    c=getch();
                    printf(“%cn”, c);
               }
               if(c==27)
                    break;          /*判断若按Esc键则退出循环*/
               i++;
               printf(“The No. is %dn”, i);
          }
          printf(“The end”);
     }
    注意:
    1. break语句对if-else的条件语句不起作用。
    2. 在多层循环中, 一个break语句只向外跳一层。

    1.3.4.2 continue 语句
    continue语句的作用是跳过循环本中剩余的语句而强行执行下一次循环。
    continue语句只用在for、while、do-while等循环体中, 常与if条件语句一
起使用, 用来加速循环。
    例20:
     main()
     {
          char c;
          while(c!=0X0D)      /*不是回车符则循环*/
          {
               c=getch();
               if(c==0X1B)
                    continue; /*若按Esc键不输出便进行下次循环*/
               printf(“%cn”, c);
          }
     }

    1.3.4.3 goto 语句
    goto语句是一种无条件转移语句, 与BASIC中的goto语句相似。goto 语句的
使用格式为:
    goto  标号;
    其中标号是Turbo C2.0中一个有效的标识符, 这个标识符加上一个”:” 一起
出现在函数内某处, 执行goto语句后, 程序将跳转到该标号处并执行其后的语句。
另外标号必须与goto语句同处于一个函数中,  但可以不在一个循环层中。通常
goto语句与if条件语句连用, 当满足某一条件时, 程序跳到标号处运行。
    goto语句通常不用, 主要因为它将使程序层次不清, 且不易读, 但在多层嵌
套退出时, 用goto语句则比较合理。
    例19用goto语句时变为:
    例21:
     main()
     {
          int i=0;
          char c;
          while(1)
          {
               c=’’;
               while(c!=13)
               {
                    c=getch();
                    if(c==27)
                      goto quit;
                    printf(“%cn”, c);
               }
               i++;
               printf(“The No. is %dn”, i);
          }
          quit:
               printf(“The end”);