緩沖文件系統

在前面的程序設計中，我們介紹了輸入和輸出，即從標準輸入設備—鍵盤輸入，由標準
輸出設備—顯示器或打印機輸出。不僅如此，我們也常把磁盤作為信息載體，用于保存中
間結果或最終數據。在使用一些字處理工具時，會利用打開一個文件來將磁盤的信息輸入到
內存，通過關閉一個文件來實現將內存數據輸出到磁盤。這時的輸入和輸出是針對文件系統，
故文件系統也是輸入和輸出的對象，談到輸入和輸出，自然也離不開文件系統。
文件可以從不同的角度來分類：
1) 按文件所依附的介質來分：有卡片文件、紙帶文件、磁帶文件、磁盤文件等。
2) 按文件內容來分：有源文件、目標文件、數據文件等。
3) 按文件中數據組織形式分：有字符文件和二進制文件。
字符文件通常又稱為A S C I I碼文件或正文文件，按字符存儲，具有可讀性；而二進制文件
是以二進制存儲，不具備可讀性，但從存儲空間的利用來看，實型數無論位數大小均占4位，
字符確需按位數來存放，這樣的話，二進制文件相對就節省了空間。
目前C語言使用的文件系統分為緩沖文件系統（標準I / O）和非緩沖文件系統（系統I / O）。
緩沖文件系統的特點是：在內存開辟一個“緩沖區”，為程序中的每一個文件使用，當執
行讀文件的操作時，從磁盤文件將數據先讀入內存“緩沖區”，裝滿后再從內存“緩沖區”依
此讀入接收的變量。執行寫文件的操作時，先將數據寫入內存“緩沖區”，待內存“緩沖區”
裝滿后再寫入文件。由此可以看出，內存“緩沖區”的大小，影響著實際操作外存的次數，
內存“緩沖區”越大，則操作外存的次數就少，執行速度就快、效率高。一般來說，文件
“緩沖區”的大小隨機器而定。
8.1.1 文件的打開與關閉
任何關于文件的操作都要先打開文件，再對文件進行讀寫，操作完畢后，要關閉文件。
1. 文件類型指針
人們在操作文件時，通常都關心文件的屬性，如文件的名字、文件的性質、文件的當前
狀態等。對緩沖文件系統來說，上述特性都是要仔細考慮的。ANSI C為每個被使用的文件在
內存開辟一塊用于存放上述信息的小區，利用一個結構體類型的變量存放。該變量的結構體
類型由系統取名為F I L E，在頭文件s t d i o . h中定義如下：
typedef struct{
i n t _ f d ; / *文件號* /
i n t _ c l e f t ; / *緩沖區中的剩余字符* /
i n t _ m o d e ; / *文件的操作模式* /
c h a r * _ n e x t ; / *下一個字符的位置* /
char *_buff; / *文件緩沖區的位置* /
} FILE；
在操作文件以前，應先定義文件變量指針：
FILE *fp1,fp2;
按照上面的定義，f p 1和f p 2均為指向結構體類型的指針變量，分別指向一個可操作的文件，
換句話說，一個文件有一個文件變量指針，今后對文件的訪問，會轉化為針對文件變量指針
的操作。
2. 文件的打開
ANSI C 提供了打開文件的函數：
FILE *fopen(char *fname,char *mode)
函數原型在s t d i o . h文件中，f o p e n ( )打開一個f n a m e指向的外部文件，返回與它相連接的流。
f n a m e是字符串，應是一個合法的文件名，還可以指明文件路經。對文件的操作模式由m o d e
決定，m o d e也是字符串，由表8 - 1給出m o d e的取值表。

如表8-1所示，文件的操作方式有文本文件和二進制文件兩種，打開文件的正確方法如下
例所示：
#include<stdio.h>
FILE *fp;
If((fp=fopen("test.txt","w"))==NULL)
{/*創建一個只寫的新文本文件*/
printf("cannotopenfile\n");
exit(0);
}
這種方法能發現打開文件時的錯誤。在開始寫文件之前檢查諸如文件是否有寫保護，磁
盤是否已寫滿等，因為函數會返回一個空指針NULL，NULL值在stdio.h中定義為0。事實上打
開文件是要向編譯系統說明三個信息：①需要訪問的外部文件是哪一個。②打開文件后要執
行讀或寫即選擇操作方式。③確定哪一個文件指針指向該文件。對打開文件所選擇的操作方
式來說，一經說明不能改變，除非關閉文件后重新打開。是只讀就不能對其寫操作，對已存文件如以新文件方式打開，則信息必丟失。
3.文件的關閉
ANSIC提供了關閉文件的函數：
intfclose(FILE*stream)
fclose()函數關閉與stream相連接的文件，并把它的緩沖區內容全部寫出。在fclose()函數
調用以后，流stream與此文件無關，同時原自動分配的緩沖區也失去定位。
fclose()函數關閉文件操作成功后，函數返回0；失敗則返回非零值。
[例8-1]打開和關閉一個可讀可寫的二進制文件：
#include<stdio.h>
main ()
{
FILE *fp;
If((fp=fopen("test.dat","rb"))==NULL)
{
printf("cannotopenfile\n");
exit(0);
}
/*寫入對文件執行讀寫的代碼
⋯⋯*/
if(fclose(fp))printf("filecloseerror!\n");
}
8.1.2文件的讀寫
當文件按指定的工作方式打開以后，就可以執行對文件的讀和寫。下面按文件的性質分
類進行操作。針對文本文件和二進制文件的不同性質，對文本文件來說，可按字符讀寫或按
字符串讀寫；對二進制文件來說，可進行成塊的讀寫或格式化的讀寫。
1.讀寫字符
C提供fgetc和fputc函數對文本文件進行字符的讀寫，其函數的原型存于stdio.h頭文件中，
格式為：
intfgetc(FILE*stream)
fgetc()函數從輸入流的當前位置返回一個字符，并將文件指針指示器移到下一個字符處，
如果已到文件尾，函數返回EOF，此時表示本次操作結束，若讀寫文件完成，則應關閉文件。
intfputc(intch,FILE*stream)
fputc（）函數完成將字符ch的值寫入所指定的流文件的當前位置處，并將文件指針后移
一位。fputc()函數的返回值是所寫入字符的值，出錯時返回EOF。
[例8-2]將存放于磁盤的指定文本文件按讀寫字符方式逐個地從文件讀出，然后再將其
顯示到屏幕上。采用帶參數的main()，指定的磁盤文件名由命令行方式通過鍵盤給定。
#include<stdio.h>
main(argc,argv)
intargc;
char*argv[];
{
char ch;
FILE *fp;
int i;
if((fp=fopen(argv[1],"r"))==NULL)/*打開一個由argv[1]所指的文件*/
{
printf("notopen");
exit(0);
}
while((ch=fgetc(fp))!=EOF)/*從文件讀一字符，顯示到屏幕*/
put char(ch);
fclose(fp);
}
程序是一帶參數的main()函數，要求以命令行方式運行，其參數argc是用于記錄輸入參數
的個數，argv是指針數組，用于存放輸入參數的字符串，串的個數由argc描述。假設我們指定
讀取的文件名為L8-2.c，并且列表文件內容就是源程序。經過編譯和連接生成可執行的文件
L8-2.exe。運行程序l8-2.exe，輸入的命令行方式為：
c:\tc>l8-2L8-2.c
上述程序以命令行方式運行，其輸入參數字符串有兩個，即argv[0]="c:\tc>l8-2"、
argv[1]="L8-2.c"，argc=2。故打開的文件是L8-2.c。程序中對fgetc()函數的返回值不斷進行
測試，若讀到文件尾部或讀文件出錯，都將返回C的整型常量EOF，其值為非零有效整數。程
序的運行輸出為源程序本身：
c:\tc>l8-2L8-2.c¿
#include<stdio.h>
main(argc,argv)
int argc;
char *argv[];
{
char ch;
FILE *fp;
int i;
if((fp=fopen(argv[1],"r"))==NULL)/*打開一個由argv[1]所指的文件*/
{
printf("not open");
exit(0);
}
while((ch=fgetc(fp))!=EOF)/*從文件讀一字符，顯示到屏幕*/
put char(ch);
fclose(fp);
}
[例8-3]從鍵盤輸入字符，存到磁盤文件test.txt中：
#include<stdio.h>
main()
{
FILE fp;/*定義文件變量指針*/
char ch;
if((fp=fopen("test.txt","w"))==NULL)/*以只寫方式打開文件*/
{
printf("cannotopenfile!\n");
exit(0);
}
while((ch=fgetchar())!='\n')/*只要輸入字符非回車符*/
fputc(ch,fp)/*寫入文件一個字符*/
fclose(fp);
}
程序通過從鍵盤輸入一以回車結束的字符串，寫入指定的流文件test.txt，文件以文本只寫方式打開，所以流文件具有可讀性，能支持各種字符處理工具訪問。簡單地說，我們可以通過DOS提供的type命令來列表顯示文件內容。

2. 讀寫字符串
C提供讀寫字符串的函數原型在s t d i o . h頭文件中，其函數形式為：
Char *fgets(char *str,int num,FILE *stream)
fgets() 函數從流文件s t r e a m中讀取至多n u m - 1個字符，并把它們放入s t r指向的字符數組中。
讀取字符直到遇見回車符或E O F（文件結束符）為止，或讀入了所限定的字符數。
int fputs(char *str,FILE *stream)
f p u t s ( )函數將s t r指向的字符串寫入流文件。操作成功時，函數返回0值，失敗返回非零值。
[例8-4] 向磁盤寫入字符串，并寫入文本文件t e s t . t x t：
#include <stdio.h>
#include <string.h>
m a i n ( )
{
FILE *fp;
char str[128];
if ((fp=fopen("test.txt","w"))==NUL/*L )打開只寫的文本文件*/
{
printf("cannot open file!");
e x i t ( 0 ) ;
}
w h i l e ( ( s t r l e n ( g e t s ( s t r ) ) ) ! = 0 )
{ /*若串長度為零，則結束* /
f p u t s ( s t r , f p ) ; / *寫入串* /
fputs("\n",fp); /*寫入回車符* /
}
fclose(fp); /*關文件* /
}
運行該程序，從鍵盤輸入長度不超過1 2 7個字符的字符串，寫入文件。如串長為0，即空串，程序結束。

這里所輸入的空串，實際為一單獨的回車符，其原因是g e t s函數判斷串的結束是以回車作
標志的。
[例8-5] 從一個文本文件t e s t 1 . t x t中讀出字符串，再寫入令一個文件t e s t 2 . t x t。
#include <stdio.h>
#include <string.h>
m a i n ( )
{
FILE *fp1,*fp2;
char str[128];
if ((fp1=fopen("test1.txt","r"))==NULL)
{ / * 以只讀方式打開文件1 * /
printf("cannot open file\n");
e x i t ( 0 ) ;
}
if ((fp2=fopen("test2.txt","w"))==NULL)
{ /*以只寫方式打開文件2 * /
printf("cannot open file\n");
e x i t ( 0 ) ;
}
while ((strlen(fgets(str,128,fp1)))>0)
/ *從文件中讀回的字符串長度大于0 */
{
fputs(str,fp2 ); / * 從文件1讀字符串并寫入文件2 * /
p r i n t f ( " % s " , s t r ) ; / *在屏幕顯示* /
}
f c l o s e ( f p 1 ) ;
f c l o s e ( f p 2 ) ;
}
程序共操作兩個文件，需定義兩個文件變量指針，因此在操作文件以前，應將兩個文件以需要的工作方式同時打開（不分先后），讀寫完成后，再關閉文件。設計過程是按寫入文件的同時顯示在屏幕上，故程序運行結束后，應看到增加了與原文件相同的文本文件并顯示文
件內容在屏幕上。
3. 格式化的讀寫
前面的程序設計中，我們介紹過利用s c a n f ( )和p r i n t f ( )函數從鍵盤格式化輸入及在顯示器
上進行格式化輸出。對文件的格式化讀寫就是在上述函數的前面加一個字母f成為f s c a n f ( )和
f p r i n t f ( )。其函數調用方式：
int fscanf(FILE *stream,char *format,arg_list)
int fprintf(FILE *stream,char *format,arg_list)
其中，s t r e a m為流文件指針，其余兩個參數與s c a n f ( )和p r i n t f ( )用法完全相同。
[例8-6] 將一些格式化的數據寫入文本文件，再從該文件中以格式化方法讀出顯示到屏
幕上，其格式化數據是兩個學生記錄，包括姓名、學號、兩科成績。
#include <stdio.h>
m a i n ( )
{
FILE *fp;
int i;
struct stu{ / *定義結構體類型* /
char name[15];
char num[6];
float score[2];
} s t u d e n t ; / *說明結構體變量* /
if ((fp=fopen("test1.txt","w"))==NULL)
{ / *以文本只寫方式打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
printf("input data:\n");
for( i=0;i<2;i++)
{
scanf("%s %s %f %f",student.name,student.num,&student.score[0],
&student.score[1]); / *從鍵盤輸入* /
fprintf(fp,"%s %s %7.2f %7.2f\n",student.name,student.num,
s t u d e n t . s c o r e [ 0 ] , s t u d e n t . s c o r e [ 1 ] ) ; / * 寫入文件* /
}
f c l o s e ( f p ) ; / *關閉文件* /
if ((fp=fopen("test.txt","r"))==NULL)
{ /*以文本只讀方式重新打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
printf("output from file:\n");
while (fscanf(fp,"%s %s %f %f\n",student.name,student.num,
& s t u d e n t . s c o r e [ 0 ] , s t u d e n t . s c o r e [ 1 ] ) ! = E O F ）
/ *從文件讀入* /
printf("%s %s %7.2f %7.2f\n",student.name,student.num,student.score[0],student.score[1]); 顯/示* 到屏幕*/
fclose(fp); /*關閉文件*/
}
程序設計一個文件變量指針，兩次以不同方式打開同一文件，寫入和讀出格式化數據，有一點很重要，那就是用什么格式寫入文件，就一定用什么格式從文件讀，否則，讀出的數據與格式控制符不一致，就造成數據出錯。上述程序運行如下：

此程序所訪問的文件也可以定為二進制文件，若打開文件的方式為：
if ((fp=fopen("test1.txt","wb"))==NULL)
{ / * 以二進制只寫方式打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
其效果完全相同。
4. 成塊讀寫
前面介紹的幾種讀寫文件的方法，對其復雜的數據類型無法以整體形式向文件寫入或從文件讀出。C語言提供成塊的讀寫方式來操作文件，使其數組或結構體等類型可以進行一次性讀寫。成塊讀寫文件函數的調用形式為：
int fread(void *buf,int size,int count,FILE *stream)
int fwrite(void *buf,int size,int count,FILE *stream)
fread （）函數從stream 指向的流文件讀取count （字段數）個字段，每個字段為s i z e (字段長度)個字符長，并把它們放到b u f（緩沖區）指向的字符數組中。
fread （）函數返回實際已讀取的字段數。若函數調用時要求讀取的字段數超過文件存放的字段數，則出錯或已到文件尾，實際在操作時應注意檢測。
f w r i t e ( )函數從b u f (緩沖區)指向的字符數組中，把c o u n t (字段數)個字段寫到s t r e a m所指向的流中，每個字段為s i z e個字符長，函數操作成功時返回所寫字段數。
關于成塊的文件讀寫，在創建文件時只能以二進制文件格式創建。
[例8-7] 向磁盤寫入格式化數據，再從該文件讀出顯示到屏幕。
#include "stdio.h"
#include "stdlib.h"
m a i n ( )
{
FILE *fp1;
int i;
struct stu{ / *定義結構體* /
char name[15];
char num[6];
float score[2];
} s t u d e n t ;
if ((fp1=fopen("test.txt","wb"))==NULL)
{ /*以二進制只寫方式打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
printf("input data:\n");
for( i=0;i<2;i++) {
scanf("%s %s %f %f",student.name,student.num,
& s t u d e n t . s c o r e [ 0 ] , & s t u d e n t . s c o r e [ 1 ] ) ; / * 輸入一記錄* /
fwrite(&student,sizeof(student),1,fp1);成 /塊*寫入文件*/
}
f c l o s e ( f p 1 ) ;
if ((fp1=fopen("test.txt","rb"))==NULL)
{ /*重新以二進制只寫打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
printf("output from file:\n");
for (i=0;i<2;i++)
{
f r e a d ( & s t u d e n t , s i z e o f ( s t u d e n t ) , 1 , f p 1 ) ; / * 從文件成塊讀* /
printf("%s %s %7.2f %7.2f\n",student.name,student.num,
s t u d e n t . s c o r e [ 0 ] , s t u d e n t . s c o r e [ 1 ] ) ; / * 顯示到屏幕* /
}
f c l o s e ( f p 1 ) ;
}

通常，對于輸入數據的格式較為復雜的話，我們可采取將各種格式的數據當做字符串輸入，然后將字符串轉換為所需的格式。C提供函數:
int atoi(char *ptr)
float atof(char *ptr)
long int atol(char *ptr)
它們分別將字符串轉換為整型、實型和長整型。使用時請將其包含的頭文件m a t h . h或s t d l i b . h寫在程序的前面。
[例8-8] 將輸入的不同格式數據以字符串輸入，然后將其轉換進行文件的成塊讀寫。
#include <stdio.h>
#include <stdlib.h>
m a i n ( )
{
FILE *fp1;
char *temp;
int i;
struct stu{ / *定義結構體類型* /
char name[15]; / *姓名* /
char num[6]; / * 學號* /
float score[2]; / * 二科成績* /
} s t u d e n t ;
if ((fp1=fopen("test.txt","wb"))==NULL) / * 打開文件* /
{
printf("cannot open file");
e x i t ( 0 ) ;
}
for( i=0;i<2;i++) {
printf("input name:");
g e t s ( s t u d e n t . n a m e ) ; / *輸入姓名* /
printf("input num:");
g e t s ( s t u d e n t . n u m ) ; / * 輸入學號* /
printf("input score1:");
g e t s ( t e m p ) ; / *輸入成績* /
s t u d e n t . s c o r e [ 0 ] = a t o f ( t e m p ) ;
printf("input score2:");
g e t s ( t e m p ) ;
s t u d e n t . s c o r e [ 1 ] = a t o f ( t e m p ) ;
f w r i t e ( & s t u d e n t , s i z e o f ( s t u d e n t ) , 1 , f p 1 ) ; / *成塊寫入到文件* /
}
f c l o s e ( f p 1 ) ;
if ((fp1=fopen("test.txt","rb"))==NULL)
{
printf("cannot open file");
e x i t ( 0 ) ;
}
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
p r i n t f ( " % - 1 5 s % - 7 s % - 7 s % - 7 s \ n " , " n a m e " , " n u m " , " s c o r e 1 " , " s c o r e 2 " ) ;
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
for (i=0;i<2;i++)
{
f r e a d ( & s t u d e n t , s i z e o f ( s t u d e n t ) , 1 , f p 1 ) ;
p r i n t f ( " % - 1 5 s % - 7 s % 7 . 2 f % 7 . 2 f \ n " , s t u d e n t . n a m e , s t u d e n t . n u m ,
s t u d e n t . s c o r e [ 0 ] , s t u d e n t . s c o r e [ 1 ] ) ;
}
f c l o s e ( f p 1 ) ;
}

8.1.3 隨機讀寫文件
隨機對文件的讀寫是指在文件內部任意對文件內容進行訪問，這也就需要對文件進行詳
細的定位，只有定位準確，才有可能對文件隨機訪問。
C語言提供了用于文件定位的函數，它的作用是使文件指針移動到所需要的位置。
int fseek(FILE *fp,long d,int pos)
f p是文件指針，d是位移量，p o s是起始點。
P o s的取值為：
0 ：文件開始處
1 ：文件的當前位置
2 ：文件的尾部
位移量d是l o n g型的數據，可以為正或負值。表示從起始點向下或向上的指針移動。函數
的返回值若操作成功為0，操作失敗為非零。
例如：f s e e k ( f p , 5 L , 0 )；將文件指針從文件頭向下移動5個字節。
f s e e k ( f p , - 1 0 L , 2 )；將文件指針從當前位置向上移動1 0個字節。
rewind() 將文件指針移動到文件頭。
ftell(FILE *fp) 返回文件指針的當前位置。
[例8-9] 寫入5個學生記錄，記錄內容為學生姓名、學號、兩科成績。寫入成功后，隨機
讀取第三條記錄，并用第二條記錄替換。
#include <stdio.h>
#include <stdlib.h>
#define n 5
m a i n ( )
{
FILE *fp1; / *定義文件指針* /
char *temp;
int i,j;
struct stu{ / * 定義學生記錄結構* /
char name[15];
char num[6];
float score[2];
} s t u d e n t [ n ] ;
if ((fp1=fopen("test.txt","wb"))==NULL) / *以二進制只寫方式打開文件* /
{
printf("cannot open file");
e x i t ( 0 ) ;
}
for( i=0;i<n;i++)
{
printf("input name:"); / *輸入姓名* /
g e t s ( s t u d e n t [ i ] . n a m e ) ;
printf("input num:");
g e t s ( s t u d e n t [ i ] . n u m ) ; / *輸入學號* /
printf("input score1:");
g e t s ( t e m p ) ; / *輸入一科成績* /
s t u d e n t [ i ] . s c o r e [ 0 ] = a t o f ( t e m p ) ;
printf("input score2:");
g e t s ( t e m p ) ; / * 輸入第二科成績* /
s t u d e n t [ i ] . s c o r e [ 1 ] = a t o f ( t e m p ) ;
fwrite(&student[i],sizeof(struct stu),1,fp1);成 塊/*寫入*/
}
fclose(fp1); /*關閉* /
if ((fp1=fopen("test.txt","rb+"))==NULL)
{ /*以可讀寫方式打開文件* /
printf("cannot open file");
e x i t ( 0 ) ;
}
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
p r i n t f ( " % - 1 5 s % - 7 s % - 7 s % - 7 s \ n " , " n a m e " , " n u m " , " s c o r e 1 " , " s c o r e 2 " ) ;
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
for (i=0;i<n;i++)
{ /*顯示全部文件內容* /
fread(&student[i],sizeof(struct stu),1,fp1);
p r i n t f ( " % - 1 5 s % - 7 s % 7 . 2 f % 7 . 2 f \ n " , s t u d e n t [ i ] . n a m e , s t u d e n t [ i ] . n u m ,
s t u d e n t [ i ] . s c o r e [ 0 ] , s t u d e n t [ i ] . s c o r e [ 1 ] ) ;
}
/ *以下進行文件的隨機讀寫* /
fseek(fp1,3*sizeof(struct stu),0)/;* 定位文件指針指向第三條記錄*/
fwrite(&student[1],sizeof(struct stu),1,fp1);
/ * 在第三條記錄處寫入第二條記錄* /
rewind(fp1); /*移動文件指針到文件頭* /
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
p r i n t f ( " % - 1 5 s % - 7 s % - 7 s % - 7 s \ n " , " n a m e " , " n u m " , " s c o r e 1 " , " s c o r e 2 " ) ;
p r i n t f ( " - - - - - - - - - - - - - - - - - - - - - \ n " ) ;
for (i=0;i<n;i++)
{ /*重新輸出文件內容* /
fread(&student[i],sizeof(struct stu),1,fp1);
p r i n t f ( " % - 1 5 s % - 7 s % 7 . 2 f % 7 . 2 f \ n " , s t u d e n t [ i ] . n a m e , s t u d e n t [ i ] . n u m ,
s t u d e n t [ i ] . s c o r e [ 0 ] , s t u d e n t [ i ] . s c o r e [ 1 ] ) ;
}
f c l o s e ( f p 1 ) ; / *關閉文件* /
}


程序的第二次輸出，即隨機訪問后，文件中會有兩條相同的記錄。

原文轉自：http://www.kjueaiud.com