黄色在线观看视频-黄色在线免费看-黄色在线视频免费-黄色在线视频免费看-免费啪啪网-免费啪啪网站

               第三章  輸入輸出函數及控制流程語句

    本章主要介紹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
     #include
     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=%d\n", a);     /*結果輸出十進制整數a=1234*/
          printf("a=%6d\n", a);    /*結果輸出6位十進制數a=  1234*/
          printf("a=%06d\n", a);   /*結果輸出6位十進制數a=001234*/
          printf("a=%2d\n", a);    /*a超過2位, 按實際值輸出a=1234*/
          printf("*i=%4d\n", *i);  /*輸出4位十進制整數*i=  12*/
          printf("*i=%-4d\n", *i); /*輸出左對齊4位十進制整數*i=12*/
          printf("i=%p\n", i);     /*輸出地址i=06E4*/
          printf("f=%f\n", f);     /*輸出浮點數f=3.141593*/
          printf("f=6.4f\n", f);   /*輸出6位其中小數點后4位的浮點數
                                      f=3.1416*/
          printf("x=%lf\n", x);    /*輸出長浮點數x=0.123457*/
          printf("x=%18.16lf\n", x);/*輸出18位其中小數點后16位的長浮點
                                      數x=0.1234567898765432*/
          printf("c=%c\n", c);     /*輸出字符c=A*/
          printf("c=%x\n", c);     /*輸出字符的ASCII碼值c=41*/
          printf("s[]=%s\n", s);   /*輸出數組字符串s[]=Hello, Comrade*/
          printf("s[]=%6.9s\n", s);/*輸出最多9個字符的字符串s[]=Hello,
                                     Co*/
          printf("s=%p\n", s);     /*輸出數組字符串首字符地址s=FFBE*/
          printf("*p=%s\n", p);    /* 輸出指針字符串p=How do you do*/
          printf("p=%p\n", p);     /*輸出指針的值p=0194*/
          getch();
          retunr 0;
     }
    上面結果中的地址值在不同計算機上可能不同。
    例1.中第一條語句#include的含義是調用另一個文件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("%s\n", p);       /*向屏幕輸出字符串*/
          printf("%s\n", 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", c2\1, c2);
     }

    運行該程序, 輸入一個字符A后回車 (要完成輸入必須回車), 在執行scanf
("%c", &c1)時, 給變量c1賦值"A", 但回車符仍然留在緩沖區內, 執行輸入語句
scanf("%c", &c2)時, 變量c2輸出的是一空行, 如果輸入AB后回車, 那么輸出結
果為: c1 is A, c2 is B。
    要解決以上問題, 可以在輸入函數前加入清除函數fflush()( 這個函數的使
用方法將在本節最后講述)。修改以上程序變成:
     #include
     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("%s\n", 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
     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
     main()
     {
          char c, ch;
          c=getch();     /*從鍵盤上讀入一個字符不回顯送給字符變量c*/
          putchar(c);    /*輸出該字符*/
          ch=getche();   /*從鍵盤上帶回顯的讀入一個字符送給字符變量ch*/
          putchar(ch);
     }
    利用回顯和不回顯的特點, 這兩個函數經常用于交互輸入的過程中完成暫停
等功能。
    例8:
     #include
     main()
     {
          char c, s[20];
          printf("Name:");
          gets(s);
          printf("Press any key to confinue...");
          getch();  /*等待輸入任一鍵*/
     }

    (2) getchar()函數
    getchar()函數也是從鍵盤上讀入一個字符, 并帶回顯。它與前面兩個函數
的區別在于: getchar()函數等待輸入直到按回車才結束,  回車前的所有輸入字
符都會逐個顯示在屏幕上。但只有第一個字符作為函數的返回值。
    getchar()函數的調用格式為:
     getchar();
    例9:
     #include
     main()
     {
          char c;
          c=getchar();   /*從鍵盤讀入字符直到回車結束*/
          putchar(c);    /*顯示輸入的第一個字符*/
          getch();       /*等待按任一健*/
     }

    1.2  文件的輸入輸出函數
    鍵盤、顯示器、打印機、磁盤驅動器等邏輯設備, 其輸入輸出都可以通過文
件管理的方法來完成。而在編程時使用最多的要算是磁盤文件, 因此本節主要以
磁盤文件為主, 詳細介紹Turbo C2.0提供的文件操作函數, 當然這些對文件的操
作函數也適合于非磁盤文件的情況。
    另外, Turbo C2.0提供了兩類關于文件的函數。一類稱做標準文件函數也稱
緩沖型文件函數, 這是ANSI標準定義的函數; 另一類叫非標準文件函數, 也稱非
緩沖型文件函數。這類函數最早公用于UNIX操作系統, 但現在MS-DOS3.0 以上版
本的操作系統也可以使用。下面分別進行介紹。

    1.2.1  標準文件函數
    標準文件函數主要包括文件的打開、關閉、讀和寫等函數。不象BASIC 、
FORTRAN語方有順序文件和隨機文件之分,   在打開時就應按不同的方式確定。
Turbo C2.0并不區分這兩種文件, 但提供了兩組函數, 即順序讀寫函數和隨機讀
寫函數。
    一、文件的打開和關閉
    任何一個文件在使用之前和使用之后, 必須要進行打開和關閉, 這是因為操
作系統對于同時打開的文件數目是有限制的, DOS操作系統中,    可以在DEVICE
.SYS中定義允許同時打開的文件數n(用files=n定義)。其中n 為可同時打開的文
件數, 一般n<=20。因此在使用文件前應打開文件, 才可對其中的信息進行存取。
用完之后需要關閉, 否則將會出現一些意想不到的錯誤。Turbo C2.0提供了打開
和關閉文件的函數。
    1. fopen()函數
    fopen函數用于打開文件, 其調用格式為:
     FILE *fopen(char *filename, *type);
    在介紹這個函數之;前, 先了解一下下面的知識。
    (1) 流(stream)和文件(file)
    流和文件 在Turbo C2.0中是有區別的, Turbo C2.0 為編程者和被訪問的設
備之間提供了一層抽象的東西, 稱之為"流", 而將具體的實際設備叫做文件。
流是一個邏輯設備, 具有相同的行為。因此, 用來進行磁盤文件寫的函數也同樣
可以用來進行打印機的寫入。在Turbo C2.0中有兩種性質的流:   文字流( text
stream)和二進制(binary stream)。對磁盤來說就是文本文件和二進制文件。本
軟件為了便于讓讀者易理解Turbo C2.0語言而沒有對流和文件作特別區分。
    (2) 文件指針FILE
    實際上FILE是一個新的數據類型。它是Turbo C2.0的基本數據類型的集合,
稱之為結構指針。有關結構的概念將在第四節中詳細介紹, 這里只要將FILE理解
為一個包括了文件管理有關信息的數據結構, 即在打開文件時必須先定義一個文
件指針。
    (3) 以后介紹的函數調用格式將直接寫出形式參數的數據類型和函數返回值
的數據類型。例如: 上面打開文件的函數, 返回一個文件指針, 其中形式參數有
兩個, 均為字符型變量(字符串數組或字符串指針)。本軟件不再對函數的調用格
式作詳細說明。
    現在再來看打開文件函數的用法。
    fopen()函數中第一個形式參數表示文件名, 可以包含路徑和文件名兩部分。
如:
     "B:TEST.DAT"
     "C:\\TC\\TEST.DAT"
    如果將路徑寫成"C:\TC\TEST.DAT"是不正確的, 這一點要特別注意。
    第二個形式參數表示打開文件的類型。關于文件類型的規定參見下表。
                       表  文件操作類型
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
          字符                含義
    ────────────────────────────
           "r"           打開文字文件只讀
           "w"           創建文字文件只寫
           "a"           增補, 如果文件不存在則創建一個
           "r+"          打開一個文字文件讀/寫
           "w+"          創建一個文字文件讀/寫
           "a+"          打開或創建一個文件增補
           "b"           二進制文件(可以和上面每一項合用)
           "t"           文這文件(默認項)
    ━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    如果要打開一個CCDOS子目錄中, 文件名為CLIB的二進制文件, 可寫成:
     fopen("c:\\ccdos\\clib", "rb");
    如果成功的打開一個文件, fopen()函數返回文件指針,   否則返回空指針
(NULL)。由此可判斷文件打開是否成功。

    2. fclose()函數
    fclose()函數用來關閉一個由fopen()函數打開的文件 , 其調用格式為:
      int fclose(FILE *stream);
    該函數返回一個整型數。當文件關閉成功時, 返回0,　否則返回一個非零值。
可以根據函數的返回值判斷文件是否關閉成功。
    例10:
     #iclude
     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, );
    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
     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, "%d\n", 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, );
     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
     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
     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
     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
     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 k\n");
          for (i=0; i<2; i++)
            for(j=0; j<2; j++)
               for(k=0; k<2; k++)
                  printf(%d %d %d\n", 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
     main()
     {
          char c;
          c='\0';             /*初始化c*/
          while(c!='\X0D')    /*回車結束循環*/
            c=getche();       /*帶回顯的從鍵盤接收字符*/
     }
    上例中, while循環是以檢查c是否為回車符開始, 因其事先被初始化為空,
所以條件為真, 進入循環等待鍵盤輸入字符; 一旦輸入回車, 則c='\X0D', 條件
為假, 循環便告結束。
    與for循環一樣, while循環總是在循環的頭部檢驗條件, 這就意味著循環可
能什么也不執行就退出。
    注意:
    1. 在while循環體內也允許空語句。
    例如:
     while((c=getche())!='\X0D');
    這個循環直到鍵入回車為止。
    2. 可以有多層循環嵌套。
    3. 語句可以是語句體, 此時必須用"{"和"}"括起來。
    例18:
     #include
     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("%d\n", test);
                         break;    /*退出開關語句*/
                    case 2:
                         printf("%d\n", test);
                         break;
                    case 3:
                         printf("%d\n", test);
                         break;
                    default:
                         puts("Error");
                         break;
               }
          }
     }
    下例的switch中變量為字符型。
    例20:
     #include
     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='\0';             /*變量賦初值*/
               while(c!=13&&c!=27) /*鍵盤接收字符直到按回車或Esc鍵*/
               {
                    c=getch();
                    printf("%c\n", c);
               }
               if(c==27)
                    break;          /*判斷若按Esc鍵則退出循環*/
               i++;
               printf("The No. is %d\n", 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("%c\n", 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='\0';
               while(c!=13)
               {
                    c=getch();
                    if(c==27)
                      goto quit;
                    printf("%c\n", c);
               }
               i++;
               printf("The No. is %d\n", i);
          }
          quit:
               printf("The end");
      }