C 和 C++ 檔案操作詳解
CPP 的檔案操作
在C++中，有一個stream這個類，所有的I/O都以這個“流”類為基礎的，包括我們要認識的檔案I/O，stream這個類有兩個重要的運算子：
1、插入器(<<)
向流輸出資料。比如說系統有一個預設的標準輸出流(cout)，一般情況下就是指的顯示器，所以，cout<<"Write Stdout"<<''\n'';就表示把字串"Write Stdout"和換行字元(''\n'')輸出到標準輸出流。
2、析取器(>>)
從流中輸入資料。比如說系統有一個預設的標準輸入流(cin)，一般情況下就是指的鍵盤，所以，cin>>x;就表示從標準輸入流中讀取一個指定型別(即變數x的型別)的資料。
在C++中，對檔案的操作是通過stream的子類fstream(file stream)來實現的，所以，要用這種方式操作檔案，就必須加入標頭檔案fstream.h。
C++ 通過以下幾個類支援檔案的輸入輸出：
- ofstream: 寫操作（輸出）的檔案類 (由ostream引申而來)
- ifstream: 讀操作（輸入）的檔案類(由istream引申而來)
- fstream: 可同時讀寫操作的檔案類 (由iostream引申而來)
開啟檔案(Open a file)
對這些類的一個物件所做的第一個操作通常就是將它和一個真正的檔案聯絡起來，也就是說開啟一個檔案。被開啟的檔案在程式中由一個流物件(stream object)來表示 (這些類的一個例項) ，而對這個流物件所做的任何輸入輸出操作實際就是對該檔案所做的操作。
1. 通過一個流物件呼叫open函式開啟一個檔案。
我們使用它的成員函式open()：void open (const char * filename, openmode mode);
這裡filename 是一個字串，代表要開啟的檔名，mode 是以下標誌符的一個組合： ios::in 為輸入(讀)而開啟檔案
檔案的輸入輸出是從記憶體的角度看的：資料載入記憶體叫做輸入，資料從記憶體到其他地方叫做輸出。
- ios::out 檔案以輸出(寫)方式開啟
- ios::in 檔案以輸入(讀)方式開啟
- ios::ate 初始位置：檔案尾
- ios::app 所有輸出附加在檔案末尾
- ios::trunc 如果檔案已存在則先刪除該檔案
- ios::binary 二進位制方式
這些識別符號可以被組合使用，中間以”或”操作符(|)間隔。例如，如果我們想要以二進位制方式開啟檔案”example.bin” 來寫入一些資料，我們可以通過以下方式呼叫成員函式open（）來實現：
ofstream file;
file.open ("example.bin", ios::out | ios::app | ios::binary);ofstream, ifstream 和 fstream所有這些類的成員函式open 都包含了一個預設開啟檔案的方式，這三個類的預設方式各不相同： 類 引數的預設方式
- ofstream ios::out | ios::trunc
- ifstream ios::in
- fstream ios::in | ios::out
只有當函式被呼叫時沒有宣告方式引數的情況下，預設值才會被採用。如果函式被呼叫時聲明瞭任何引數，預設值將被完全改寫，而不會與呼叫引數組合。
2. 通過 類 物件 建構函式 開啟檔案。
類 ofstream, ifstream 和 fstream 的 物件 所進行的第一個操作通常都是開啟檔案，這些類都有一個建構函式可以直接呼叫open 函式，並擁有同樣的引數。這樣，我們就可以通過以下方式進行與上面同樣的定義物件和開啟檔案的操作：
ofstream file ("example.bin", ios::out | ios::app | ios::binary);
例如：以二進位制輸入方式開啟檔案c:\config.sys
fstream file1;
file1.open("c:\\config.sys",ios::binary|ios::in,0);
//如果open函式只有檔名一個引數，則是以讀/寫普通檔案開啟，即：
file1.open("c:\\config.sys");<=>file1.open("c:\\config.sys",ios::in|ios::out,0);
//另外，fstream還有和open()一樣的建構函式，對於上例，在定義的時侯就可以開啟檔案了：
fstream file1("c:\\config.sys");以上 兩種 開啟檔案的方式都是正確的。
通過呼叫成員函式is_open()來檢查一個檔案是否已經被順利的開啟：bool is_open()。它返回一個布林(bool)值，為真（true）代表檔案已經被順利開啟，假( false )則相反。
#include <fstream>
ofstream //檔案寫操作 記憶體寫入儲存裝置
ifstream //檔案讀操作，儲存裝置讀區到記憶體中
fstream //讀寫操作，對開啟的檔案可進行讀寫操作在fstream類中，成員函式open（）實現開啟檔案的操作，從而將資料流和檔案進行關聯，通過ofstream,ifstream,fstream物件 進行對檔案的讀寫操作
在fstream類中，有一個成員函式open()，就是用來開啟檔案的，其原型是：
void open(const char* filename,int mode,int access);
引數：
filename： 要開啟的檔名
mode： 要開啟檔案的方式
access： 開啟檔案的屬性開啟檔案的方式在類ios(是所有流式I/O類的基類)中定義，常用的值如下：
ios::app： 以追加的方式開啟檔案
ios::ate： 檔案開啟後定位到檔案尾，ios:app就包含有此屬性
ios::binary： 以二進位制方式開啟檔案，預設的方式是文字方式。兩種方式的區別見前文
ios::in： 檔案以輸入(讀)方式開啟
ios::out： 檔案以輸出(寫)方式開啟
ios::nocreate： 不建立檔案，所以檔案不存在時開啟失敗
ios::noreplace：不覆蓋檔案，所以開啟檔案時如果檔案存在失敗
ios::trunc： 如果檔案存在，把檔案長度設為0。即刪除該檔案。可以用“或”把以上屬性連線起來，如ios::out|ios::binary
ofstream out;
out.open("Hello.txt", ios::in|ios::out|ios::binary) //根據自己需要進行適當的選取 開啟檔案的屬性取值是：
0：普通檔案，開啟訪問
1：只讀檔案
2：隱含檔案
4：系統檔案可以用“或”或者“+”把以上屬性連線起來 ，如3或1|2就是以只讀和隱含屬性開啟檔案。
例如：以二進位制輸入方式開啟檔案c:config.sys
fstream file1;
file1.open("c:config.sys",ios::binary|ios::in,0);
// 如果open函式只有檔名一個引數，則是以讀/寫普通檔案開啟，即：
// file1.open("c:config.sys");<=>file1.open("c:config.sys",ios::in|ios::out,0);
// 另外，fstream還有和open()一樣的建構函式，對於上例，在定義的時侯就可以開啟檔案了：
fstream file1("c:config.sys");
// fstream有兩個子類：ifstream(input file stream)和ofstream(outpu file stream)，ifstream預設以輸入方式開啟檔案，而ofstream預設以輸出方式開啟檔案。
ifstream file2("c:pdos.def");//以輸入方式開啟檔案
ofstream file3("c:x.123");//以輸出方式開啟檔案
所以，在實際應用中，根據需要的不同，選擇不同的類來定義：如果想以輸入方式開啟，就用ifstream來定義；如果想以輸出方式開啟，就用ofstream來定義；如果想以輸入/輸出方式來開啟，就用fstream來定義。很多程式中，可能會碰到ofstream out("Hello.txt"), ifstream in("..."),fstream foi("...")這樣的的使用，並沒有顯式的去呼叫open（）函式就進行檔案的操作，直接呼叫了其預設的開啟方式，因為在stream類的建構函式中呼叫了open()函式,並擁有同樣的建構函式，所以在這裡可以直接使用流物件進行檔案的操作，預設方式如下：
ofstream out("...", ios::out);
ifstream in("...", ios::in);
fstream foi("...", ios::in|ios::out); 當使用預設方式進行對檔案的操作時，你可以使用成員函式is_open()對檔案是否開啟進行驗證
關閉檔案(Closing a file)
當檔案讀寫操作完成之後，我們必須將檔案關閉以使檔案重新變為可訪問的。關閉檔案需要呼叫成員函式close()，它負責將快取中的資料排放出來並關閉檔案。
void close (); 這個函式一旦被呼叫，原先的流物件(stream object)就可以被用來開啟其它的檔案了，這個檔案也就可以重新被其它的程序(process)所有訪問了。
為防止流物件被銷燬時還聯絡著開啟的檔案，解構函式(destructor)將會自動呼叫關閉函式close。
開啟的檔案使用完成後一定要關閉，fstream提供了成員函式close()來完成此操作，如：file1.close();就把file1相連的檔案關閉。
讀寫檔案
讀寫檔案分為 文字檔案 和 二進位制檔案 的讀取，
對於文字檔案的讀取比較簡單，用插入器和析取器就可以。而對於二進位制的讀取就要複雜些。
下要就詳細的介紹這兩種方式：
文字檔案(Text mode files)
類ofstream, ifstream 和fstream 是分別從ostream, istream 和iostream 中引申而來的。這就是為什麼 fstream 的物件可以使用其父類的成員來訪問資料。
一般來說，我們將使用這些類與同控制檯(console)互動同樣的成員函式(cin 和 cout)來進行輸入輸出。如下面的例題所示，我們使用過載的插入操作符
文字檔案的讀寫很簡單：用插入器(>>)從檔案輸入。假設file1是以輸入方式開啟，file2以輸出開啟。示例如下：
file2<<"I Love You";//向檔案寫入字串"I Love You"
int i;
file1>>i;//從檔案輸入一個整數值。這種方式還有一種簡單的格式化能力，比如可以指定輸出為16進位制等等，具體的格式有以下一些
操縱符 功能 輸入/輸出
dec 格式化為十進位制數值資料 輸入和輸出
endl 輸出一個換行符並重新整理此流 輸出
ends 輸出一個空字元 輸出
hex 格式化為十六進位制數值資料 輸入和輸出
oct 格式化為八進位制數值資料 輸入和輸出
setpxecision(int p) 設定浮點數的精度位數 輸出
比如要把123當作十六進位制輸出：file1<<hex<<123;要把3.1415926以5位精度輸出：file1<<setpxecision(5)<<3.1415926。
類ofstream, ifstream 和fstream 是分別從ostream, istream 和iostream 中引申而來的。這就是為什麼 fstream 的物件可以使用其父類的成員來訪問資料。
一般來說，我們將使用這些類與同控制檯(console)互動同樣的成員函式(cin 和 cout)來進行輸入輸出。如下面的例題所示，我們使用過載的插入操作符<<：
// writing on a text file
#include <fiostream.h>
int main () {
ofstream out("out.txt");
if (out.is_open())
{
out << "This is a line.\n";
out << "This is another line.\n";
out.close();
}
return 0;
}
//結果: 在out.txt中寫入：
This is a line.
This is another line
從檔案中讀入資料也可以用與 cin>>的使用同樣的方法：
// reading a text file
#include <iostream.h>
#include <fstream.h>
#include <stdlib.h>
int main () {
char buffer[256];
ifstream in("test.txt");
if (! in.is_open())
{ cout << "Error opening file"; exit (1); }
while (!in.eof() )
{
in.getline (buffer,100);
cout << buffer << endl;
}
return 0;
}
//結果 在螢幕上輸出
This is a line.
This is another line例子中讀入一個文字檔案的內容，然後將它列印到螢幕上。注意我們使用了一個新的成員函式叫做eof ，它是ifstream 從類 ios 中繼承過來的，當到達檔案末尾時返回true 。
二進位制檔案(Binary files)
在二進位制檔案中，使用<< 和>>，以及函式（如getline）來操作符輸入和輸出資料，沒有什麼實際意義，雖然它們是符合語法的。
檔案流包括兩個為順序讀寫資料特殊設計的成員函式：write 和 read。第一個函式 (write) 是ostream 的一個成員函式，都是被ofstream所繼承。而read 是istream 的一個成員函式，被ifstream 所繼承。類 fstream 的物件同時擁有這兩個函式。它們的原型是：
write ( char * buffer, streamsize size );
read ( char * buffer, streamsize size );
這裡 buffer 是一塊記憶體的地址，用來儲存或讀出資料。引數size 是一個整數值，表示要從快取（buffer）中讀出或寫入的字元數。
// reading binary file
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
const char * filename = "example.txt";
char * buffer;
long size;
ifstream file(filename, ios::in|ios::binary|ios::ate);
size = file.tellg();
file.seekg(0, ios::beg);
buffer = new char [size];
file.read(buffer, size);
file.close();
cout <<"the complete file is in a buffer";
delete[] buffer;
return 0;
}
//The complete file is in a buffer①put()
put()函式向流寫入一個字元，其原型是ofstream &put(char ch)，使用也比較簡單，如file1.put(‘c’);就是向流寫一個字元’c’。
②get()
get()函式比較靈活，有3種常用的過載形式：
一種就是和put()對應的形式：ifstream &get(char &ch);功能是從流中讀取一個字元，結果儲存在引用ch中，如果到檔案尾，返回空字元。如file2.get(x);表示從檔案中讀取一個字元，並把讀取的字元儲存在x中。
另一種過載形式的原型是： int get();這種形式是從流中返回一個字元，如果到達檔案尾，返回EOF，如x=file2.get();和上例功能是一樣的。
還 有一種形式的原型是：ifstream &get(char *buf,int num,char delim=’n’)；這種形式把字元讀入由 buf 指向的陣列，直到讀入了 num 個字元或遇到了由 delim 指定的字元，如果沒使用 delim 這個引數，將使用預設值換行符’n’。例如：
file2.get(str1,127,’A’);//從檔案中讀取字元到字串str1，當遇到字元’A’或讀取了127個字元時終止。
③讀寫資料塊
要讀寫二進位制資料塊，使用成員函式read()和write()成員函式，它們原型如下：
read(unsigned char *buf,int num);
write(const unsigned char *buf,int num);
read() 從檔案中讀取 num 個字元到 buf 指向的快取中，如果在還未讀入 num 個字元時就到了檔案尾，可以用成員函式 int gcount();來取得實際讀取的字元數；而 write() 從buf 指向的快取寫 num 個字元到檔案中，值得注意的是快取的型別是 unsigned char *，有時可能需要型別轉換。
unsigned char str1[]="I Love You";
int n[5];
ifstream in("xxx.xxx");
ofstream out("yyy.yyy");
out.write(str1,strlen(str1));//把字串str1全部寫到yyy.yyy中
in.read((unsigned char*)n,sizeof(n));//從xxx.xxx中讀取指定個整數，注意型別轉換
in.close();out.close();狀態標誌符的驗證(Verification of state flags)
除了eof()以外，還有一些驗證流的狀態的成員函式（所有都返回bool型返回值）：
bad()：如果在讀寫過程中出錯，返回 true 。例如：當我們要對一個不是開啟為寫狀態的檔案進行寫入時，或者我們要寫入的裝置沒有剩餘空間的時候。
fail()：除了與bad() 同樣的情況下會返回 true 以外，加上格式錯誤時也返回true ，例如當想要讀入一個整數，而獲得了一個字母的時候。
eof()：如果讀檔案到達檔案末尾，返回true。
good()：這是最通用的：如果呼叫以上任何一個函式返回true 的話，此函式返回 false 。
要想重置以上成員函式所檢查的狀態標誌，你可以使用成員函式clear()，沒有引數。
快取和同步(Buffers and Synchronization)
當我們對檔案流進行操作的時候，它們與一個streambuf 型別的快取(buffer)聯絡在一起。這個快取（buffer）實際是一塊記憶體空間，作為流(stream)和物理檔案的媒介。例如，對於一個輸出流， 每次成員函式put (寫一個單個字元)被呼叫，這個字元不是直接被寫入該輸出流所對應的物理檔案中的，而是首先被插入到該流的快取（buffer）中。
當快取被排放出來(flush)時，它裡面的所有資料或者被寫入物理媒質中（如果是一個輸出流的話），或者簡單的被抹掉(如果是一個輸入流的話)。這個過程稱為同步(synchronization)，它會在以下任一情況下發生：
1. 當檔案被關閉時: 在檔案被關閉之前，所有還沒有被完全寫出或讀取的快取都將被同步。
2. 當快取buffer 滿時:快取Buffers 有一定的空間限制。當快取滿時，它會被自動同步。
3. 控制符明確指明:當遇到流中某些特定的控制符時，同步會發生。這些控制符包括：flush 和endl。
4. 明確呼叫函式sync(): 呼叫成員函式sync() (無引數)可以引發立即同步。這個函式返回一個int 值，等於-1 表示流沒有聯絡的快取或操作失敗
檢測 EOF
成員函式eof()用來檢測是否到達檔案尾，如果到達檔案尾返回非0值，否則返回0。原型是int eof();
if(in.eof())ShowMessage("已經到達檔案尾！");
檔案定位
和 C的檔案操作方式不同的是，C++ I/O系統管理兩個與一個檔案相聯絡的指標。一個是讀指標，它說明輸入操作在檔案中的位置；另一個是寫指標，它下次寫操作的位置。每次執行輸入或輸出時， 相應的指標自動變化。所以，C++的檔案定位分為讀位置和寫位置的定位，對應的成員函式是 seekg()和 seekp()，seekg()是設定讀位置，seekp是設定寫位置。它們最通用的形式如下：
istream &seekg(streamoff offset,seek_dir origin);
ostream &seekp(streamoff offset,seek_dir origin);streamoff 定義於 iostream.h 中，定義有偏移量 offset 所能取得的最大值，seek_dir 表示移動的基準位置，是一個有以下值的列舉：
ios::beg： 檔案開頭
ios::cur： 檔案當前位置
ios::end： 檔案結尾這兩個函式一般用於二進位制檔案，因為文字檔案會因為系統對字元的解釋而可能與預想的值不同。
file1.seekg(1234,ios::cur);//把檔案的讀指標從當前位置向後移1234個位元組
file2.seekp(1234,ios::beg);//把檔案的寫指標從檔案開頭向後移1234個位元組獲得和設定流指標(get and put stream pointers)
所有輸入/輸出流物件(i/o streams objects)都有至少一個流指標：
ifstream， 類似istream, 有一個被稱為get pointer的指標，指向下一個將被讀取的元素。
ofstream, 類似 ostream, 有一個指標 put pointer ，指向寫入下一個元素的位置。
fstream, 類似 iostream, 同時繼承了get 和 put
我們可以通過使用以下成員函式來讀出或配置這些指向流中讀寫位置的流指標：
tellg() 和 tellp()
這兩個成員函式不用傳入引數，返回pos_type 型別的值(根據ANSI-C++ 標準) ，就是一個整數，代表當前get 流指標的位置 (用tellg) 或 put 流指標的位置(用tellp).
seekg() 和seekp()
這對函式分別用來改變流指標get 和put的位置。兩個函式都被過載為兩種不同的原型：
seekg ( pos_type position );
seekp ( pos_type position );使用這個原型，流指標被改變為指向從檔案開始計算的一個絕對位置。要求傳入的引數型別與函式 tellg 和tellp 的返回值型別相同。
seekg ( off_type offset, seekdir direction );
seekp ( off_type offset, seekdir direction );使用這個原型可以指定由引數direction決定的一個具體的指標開始計算的一個位移(offset)。它可以是：
ios::beg 從流開始位置計算的位移
ios::cur 從流指標當前位置開始計算的位移
ios::end 從流末尾處開始計算的位移流指標 get 和 put 的值對文字檔案(text file)和二進位制檔案(binary file)的計算方法都是不同的，因為文字模式的檔案中某些特殊字元可能被修改。由於這個原因，建議對以文字檔案模式開啟的檔案總是使用seekg 和 seekp的第一種原型，而且不要對tellg 或 tellp 的返回值進行修改。對二進位制檔案，你可以任意使用這些函式，應該不會有任何意外的行為產生。
以下例子使用這些函式來獲得一個二進位制檔案的大小：
// obtaining file size
#include <iostream>
#include <fstream>
using namespace std;
int main ()
{
const char * filename = "example.txt";
long l,m;
ifstream file(filename, ios::in|ios::binary);
l = file.tellg();
file.seekg(0, ios::end);
m = file.tellg();
file.close();
cout <<"size of "<< filename;
cout <<" is "<< (m-l)<<" bytes.\n";
return 0;
}
//size of example.txt is 40 bytes.C語言檔案操作詳解
基於C的檔案操作
在ANSI C中，對檔案的操作分為兩種方式，即流式檔案操作和I/O檔案操作，下面就分別介紹之。
一、流式檔案操作：這種方式的檔案操作有一個重要的結構FILE，FILE在stdio.h中定義如下：
typedef struct
{
short level; /* fill/empty level of buffer */
unsigned flags; /* File status flags */
char fd; /* File descriptor */
unsigned char hold; /* Ungetc char if no buffer */
short bsize; /* Buffer size */
unsigned char *buffer; /* Data transfer buffer */
unsigned char *curp; /* Current active pointer */
unsigned istemp; /* Temporary file indicator */
short token; /* Used for validity checking */
}FILE; /* This is the FILE object */
FILE這個結構包含了檔案操作的基本屬性，對檔案的操作都要通過這個結構的指標來進行。C語言中沒有輸入輸出語句，所有的輸入輸出功能都用 ANSI C提供的一組標準庫函式來實現。檔案操作標準庫函式有：
檔案的開啟操作 fopen 開啟一個檔案
檔案的關閉操作 fclose 關閉一個檔案
檔案的讀寫操作 fgetc 從檔案中讀取一個字元
fputc 寫一個字元到檔案中去
fgets 從檔案中讀取一個字串
fputs 寫一個字串到檔案中去
fprintf 往檔案中寫格式化資料
fscanf 格式化讀取檔案中資料
fread 以二進位制形式讀取檔案中的資料
fwrite 以二進位制形式寫資料到檔案中去
getw 以二進位制形式讀取一個整數
putw 以二進位制形式存貯一個整數
檔案狀態檢查函式 feof 檔案結束
ferror 檔案讀/寫出錯
clearerr 清除檔案錯誤標誌
ftell 瞭解檔案指標的當前位置
檔案定位函式 rewind 反繞
fseek 隨機定位檔案的開啟
1．函式原型：FILE *fopen(char *pname,char *mode)
2．功能說明
按照mode 規定的方式，開啟由pname指定的檔案。若找不到由pname指定的相應檔案，就按以下方式之一處理：
（1） 此時如mode 規定按寫方式開啟檔案，就按由pname指定的名字建立一個新檔案；
（2） 此時如mode 規定按讀方式開啟檔案，就會產生一個錯誤。
開啟檔案的作用是：
（1）分配給開啟檔案一個FILE 型別的檔案結構體變數，並將有關資訊填入檔案結構體變數；
（2）開闢一個緩衝區；
（3）呼叫作業系統提供的開啟檔案或建立新檔案功能，開啟或建立指定檔案；
FILE *：指出fopen是一個返回檔案型別的指標函式；
3．引數說明
pname：是一個字元指標，指向要開啟的檔名。
mode：是一個指向檔案處理方式字串的字元指標。
字串 含義
"r" 開啟只讀檔案，該檔案必須存在。
"w" 開啟只寫檔案，若檔案存在則檔案長度清為0，即該檔案內容會消失。若檔案不存在則建立該檔案。
"a" 以追加方式開啟只寫檔案。檔案不存在建立該檔案，如檔案存在，寫入的資料會被加到檔案尾，即檔案原先的內容會被保留。
"r+" 以讀/寫方式開啟檔案，該檔案必須存在。如無檔案則出錯
"w+" 以讀/寫方式開啟檔案，若檔案存在則檔案長度清為零，即檔案內容清空。若檔案不存在則建立該檔案。上述的形態字串都可以再加一個b字元，如rb、w+b或ab＋等組合，加入b 字元用來告訴函式庫開啟的檔案為二進位制檔案，而非純文字檔案。不過在POSIX系統，包含Linux都會忽略該字元。由fopen()所建立的新檔案會具有S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH(0666)許可權，此檔案許可權也會參考umask值。
返回值 檔案順利開啟後，指向該流的檔案指標就會被返回。若果檔案開啟失敗則返回NULL，並把錯誤程式碼存在errno 中。
附加說明 一般而言，開檔案後會作一些檔案讀取或寫入的動作，若開檔案失敗，接下來的讀寫動作也無法順利進行，所以在fopen()後請作錯誤判斷及處理。
一個檔案可以以文字模式或二進位制模式開啟，這兩種的區別是：在文字模式中回車被當成一個字元''\n''，而二進位制模式認為它是兩個字元0x0D,0x0A；如果在檔案中讀到0x1B，文字模式會認為這是檔案結束符，也就是二進位制模型不會對檔案進行處理，而文字方式會按一定的方式對資料作相應的轉換。
系統預設的是以文字模式開啟，可以修改全部變數_fmode的值來修改這個設定，例如_fmode=O_TEXT；就設定預設開啟方式為文字模式；而_fmode=O_BINARY；則設定預設開啟方式是二進位制模式。
我們也可以在模式字串中指定開啟的模式，如"rb"表示以二進位制模式開啟只讀檔案，"w+t"或"wt+"表示以文字模式開啟讀/寫檔案。
此函式返回一個FILE指標，所以申明一個FILE指標後不用初始化，而是用fopen()來返回一個指標並與一個特定的檔案相連，如果成敗，返回NULL。
4．返回值
正常返回：被開啟檔案的檔案指標。
異常返回：NULL，表示開啟操作不成功。
//定義一個名叫fp檔案指標
FILE *fp；
//判斷按讀方式開啟一個名叫test的檔案是否失敗
if((fp=fopen（"test"，"r"）) == NULL)//開啟操作不成功
{
printf("The file can not be opened.\n")；
exit(1);//結束程式的執行
}
FILE *fp;
if(fp=fopen("123.456","wb"))
puts("開啟檔案成功");
else
puts("開啟檔案成敗");要說明的是：C語言將計算機的輸入輸出裝置都看作是檔案。例如，鍵盤檔案、螢幕檔案等。ANSI C標準規定，在執行程式時系統先自動開啟鍵盤、螢幕、錯誤三個檔案。這三個檔案的檔案指標分別是：標準輸入stdin、標準輸出stdout和標準出錯 stderr。
freopen（開啟檔案）
相關函式 fopen，fclose
表頭檔案 #include<stdio.h>
定義函式 FILE * freopen(const char * path,const char * mode,FILE * stream);
函式說明 引數path字串包含欲開啟的檔案路徑及檔名，引數mode請參考fopen()說明。引數stream為已開啟的檔案指標。Freopen()會將原stream所開啟的檔案流關閉，然後開啟引數path的檔案。
返回值 檔案順利開啟後，指向該流的檔案指標就會被返回。如果檔案開啟失敗則返回NULL，並把錯誤程式碼存在errno 中。
#include<stdio.h>
main()
{
FILE * fp;
fp=fopen(“/etc/passwd”,”r”);
fp=freopen(“/etc/group”,”r”,fp);
fclose(fp);
}檔案的關閉
1． 函式原型：int fclose(FILE *fp)；
2． 功能說明
關閉由fp指出的檔案。此時呼叫作業系統提供的檔案關閉功能，關閉由fp->fd指出的檔案；釋放由fp指出的檔案型別結構體變數；返回操作結果，即0或EOF。
3． 引數說明
fp：一個已開啟檔案的檔案指標。
4． 返回值
正常返回：0。
異常返回：EOF，表示檔案在關閉時發生錯誤。
例如：
int n=fclose(fp);檔案的讀寫操作
1. 從檔案中讀取一個字元
1． 函式原型：int fgetc(FILE *fp)；
2． 功能說明：從fp所指檔案中讀取一個字元。
3． 引數說明：fp：這是個檔案指標，它指出要從中讀取字元的檔案。
4． 返回值
正常返回： 返回讀取字元的程式碼。
非正常返回：返回EOF。例如，要從"寫開啟"檔案中讀取一個字元時，會發生錯誤而返回一個EOF。
//顯示指定檔案的內容。
//程式名為：display.c
//執行時可用：display filename1 形式的命令列執行。顯示檔案filename1中的內容。例如，執行命令列display display.c將在螢幕上顯示display的原始碼。
//File display program.
#include <stdio.h>
void main(int argc,char *argv[]) //命令列引數
{
int ch;//定義檔案型別指標
FILE *fp;//判斷命令列是否正確
if(argc!=2)
{
printf("Error format,Usage: display filename1\n");
return; //鍵入了錯誤的命令列，結束程式的執行
}
//按讀方式開啟由argv[1]指出的檔案
if((fp=fopen(argv[1],"r"))==NULL)
{
printf("The file <%s> can not be opened.\n",argv[1]);//開啟操作不成功
return;//結束程式的執行
}
//成功打開了argv[1]所指檔案
ch=fgetc(fp); //從fp所指檔案的當前指標位置讀取一個字元
while(ch!=EOF) //判斷剛讀取的字元是否是檔案結束符
{
putchar(ch); //若不是結束符，將它輸出到螢幕上顯示
ch=fgetc(fp); //繼續從fp所指檔案中讀取下一個字元
} //完成將fp所指檔案的內容輸出到螢幕上顯示
fclose(fp); //關閉fp所指檔案
}2. 寫一個字元到檔案中去
1． 函式原型：int fputc(int ch,FILE *fp)
2． 功能說明：把ch中的字元寫入由fp指出的檔案中去。
3． 引數說明
ch：是一個整型變數，記憶體要寫到檔案中的字元（C語言中整型量和字元量可以通用）。
fp：這是個檔案指標，指出要在其中寫入字元的檔案。
4． 返回值
正常返回： 要寫入字元的程式碼。
非正常返回：返回EOF。例如，要往"讀開啟"檔案中寫一個字元時，會發生錯誤而返回一個EOF。
//將一個檔案的內容複製到另一個檔案中去。
//程式名為：copyfile.c
//執行時可用：copyfile filename1 filename2形式的命令列執行，將檔案filename1中的內容複製到檔案filename2中去。
//file copy program.
#include <stdio.h>
void main(int argc,char *argv[]) //命令列引數
{
int ch;
FILE *in,*out; //定義in和out兩個檔案型別指標
if(argc!=3) //判斷命令列是否正確
{
printf("Error in format,Usage: copyfile filename1 filename2\n");
return; //命令列錯，結束程式的執行
}
//按讀方式開啟由argv[1]指出的檔案
if((in=fopen(argv[1],"r"))==NULL)
{
printf("The file <%s> can not be opened.\n",argv[1]);
return; //開啟失敗，結束程式的執行
}
//成功打開了argv[1]所指檔案，再
//按寫方式開啟由argv[2]指出的檔案
if((out=fopen(argv[2],"w"))==NULL)
{
printf("The file %s can not be opened.\n",argv[2]);
return; //開啟失敗，結束程式的執行
}
//成功打開了argv[2]所指檔案
ch=fgetc(in); //從in所指檔案的當前指標位置讀取一個字元
while(ch!=EOF) //判斷剛讀取的字元是否是檔案結束符
{
fputc(ch,out); //若不是結束符，將它寫入out所指檔案
ch=fgetc(in); //繼續從in所指檔案中讀取下一個字元
} //完成將in所指檔案的內容寫入（複製）到out所指檔案中
fclose(in); //關閉in所指檔案
fclose(out); //關閉out所指檔案
}示例程式碼
//按十進位制和字元顯示檔案程式碼，若遇不可示字元就用井號"#"字元代替之。
//程式名為：dumpf.c
//執行時可用：dumpf filename1 形式的命令列執行。
// File dump program.
#include <stdio.h>
void main(int argc,char *argv[])
{
char str[9];
int ch,count,i;
FILE *fp;
if(argc!=2)
{
printf("Error format,Usage: dumpf filename\n");
return;
}
if((fp=fopen(argv[1],"r"))==NULL)
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
count=0;
do{
i=0;
//按八進位制輸出第一列，作為一行八個位元組的首地址
printf("%06o: ",count*8);
do{
// 從開啟的檔案中讀取一個字元
ch=fgetc(fp);
// 按十進位制方式輸出這個字元的ASCII碼
printf("%4d",ch);
// 如果是不可示字元就用"#"字元代替
if(ch<' '||ch>'~') str[i]='#';
// 如果是可示字元，就將它存入陣列str以便形成字串
else str[i]=ch;
// 保證每一行輸出八個字元
if(++i==8) break;
}while(ch!=EOF); // 遇到檔案尾標誌，結束讀檔案操作
str[i]='\0'; // 在陣列str加字串結束標誌
for(;i<8;i++) printf(" "); // 一行不足八個字元用空格填充
printf(" %s\n",str); // 輸出字串
count++; // 準備輸出下一行
}while(ch!=EOF); // 直到檔案結束
fclose(fp); // 關閉fp所指檔案
}3. 從檔案中讀取一個字串
1． 函式原型：char *fgets(char *str,int n,FILE *fp)
2． 功能說明
從由fp指出的檔案中讀取n-1個字元，並把它們存放到由str指出的字元陣列中去，最後加上一個字串結束符'\0'。
3． 引數說明
str：接收字串的記憶體地址，可以是陣列名，也可以是指標。
n： 指出要讀取字元的個數。
fp：這是個檔案指標，指出要從中讀取字元的檔案。
4． 返回值
正常返回：返回字串的記憶體首地址，即str的值。
非正常返回：返回一個NULL值，此時應當用feof()或ferror()函式來判別是讀取到了檔案尾，還是發生了錯誤。例如，要從"寫開啟"檔案中讀取字串，將
發生錯誤而返回一個NULL值。
4. 寫一個字串到檔案中去
1． 函式原型：int fputs(char *str,FILE *fp)
2． 功能說明
把由str指出的字串寫入到fp所指的檔案中去。
3． 引數說明
str：指出要寫到檔案中去的字串。
fp：這是個檔案指標，指出字串要寫入其中的檔案。
4． 返回值
正常返回： 寫入檔案的字元個數，即字串的長度。
非正常返回：返回一個NULL值，此時應當用feof()或ferror()函式來判別是讀取到了檔案尾，還是發生了錯誤。例如，要往一個"讀開啟" 檔案中寫字串時，
會發生錯誤而返回一個NULL值。
//以下程式將一個檔案的內容附加到另一個檔案中去。
//程式名：linkfile.c
//執行時可用：linkfile filename1 filename2形式的命令列執行，將檔案filename2的內容附加在檔案filename1之後。
// file linked program.
#include <stdio.h>
#define SIZE 512
void main(int argc,char *argv[])
{
char buffer[SIZE];
FILE *fp1,*fp2;
if(argc!=3)
{
printf("Usage: linkfile filename1 filename2\n");
return;
}
// 按追加方式開啟argv[1] 所指檔案
if((fp1=fopen(argv[1],"a"))==NULL)
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
if((fp2=fopen(argv[2],"r"))==NULL)
{
printf("The file %s can not be opened.\n",argv[2]);
return;
}
// 讀入一行立即寫出，直到檔案結束
while(fgets(buffer,SIZE,fp1)!=NULL)
printf("%s\n",buffer);
while(fgets(buffer,SIZE,fp2)!=NULL)
fputs(buffer,fp1);
fclose(fp1);
fclose(fp2);
if((fp1=fopen(argv[1],"r"))==NULL)
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
while(fgets(buffer,SIZE,fp1)!=NULL)
printf("%s\n",buffer);
fclose(fp1);
}5. 往檔案中寫格式化資料
1．函式原型：int fprintf(FILE *fp,char *format,arg_list)
2．功能說明
將變量表列（arg_list）中的資料，按照format指出的格式，寫入由fp指定的檔案。fprintf()函式與printf()函式的功能相同，只是printf()函式是將資料寫入螢幕檔案（stdout）。
3．引數說明
fp：這是個檔案指標，指出要將資料寫入的檔案。
format：這是個指向字串的字元指標，字串中含有要寫出資料的格式，所以該字串成為格式串。格式串描述的規則與printf()函式中的格式串相同。
arg_list：是要寫入檔案的變量表列，各變數之間用逗號分隔。
4．返回值：無。
// 下列程式的執行檔案為display.exe，執行時鍵入命令列：
// display [-i][-s] filename
// 下面的表格列出了命令列引數的含義及其功能：
//儲存檔名：save.txt
//程式程式碼如下：
// file display program.
#include <stdio.h>
void main()
{
char name[10];
int nAge,nClass;
long number;
FILE *fp;
if((fp=fopen("student.txt","w"))==NULL)
{
printf("The file %s can not be opened.\n","student.txt");
return;
}
fscanf(stdin,"%s %d %d %ld",name,&nClass,&nAge,&number);
fprintf(fp,"%s %5d %4d %8ld",name,nClass,nAge,number);
fclose(fp);
if((fp=fopen("student.txt","r"))==NULL)
{
printf("The file %s can not be opened.\n","student.txt");
return;
}
fscanf(fp,"%s %d %d %ld",name,&nClass,&nAge,&number);
printf("name nClass nAge number\n");
fprintf(stdout,"%-10s%-8d%-6d%-8ld\n",name,nClass,nAge,number);
fclose(fp);
}fscanf 從一個流中執行格式化輸入
表頭檔案：#include<stdio.h>
函式原型：int fscanf(FILE *stream, char *format[,argument...]);
FILE* 一個FILE型的指標
char* 格式化輸出函式，和scanf裡的格式一樣
返回值：成功時返回轉換的位元組數，失敗時返回一個負數
fp = fopen("/local/test.c","a+");
fscanf(fp,"%s",str);
fdopen（將檔案描述詞轉為檔案指標）
相關函式 fopen，open，fclose
表頭檔案 #include<stdio.h>
定義函式 FILE * fdopen(int fildes,const char * mode);
函式說明 fdopen()會將引數fildes 的檔案描述詞，轉換為對應的檔案指標後返回。引數mode 字串則代表著檔案指標的流形態，此形態必須和原先檔案描述詞讀寫模式相同。關於mode 字串格式請參考fopen()。
返回值 轉換成功時返回指向該流的檔案指標。失敗則返回NULL，並把錯誤程式碼存在errno中。
#include<stdio.h>
main()
{
FILE * fp =fdopen(0,”w+”);
fprintf(fp,”%s/n”,”hello!”);
fclose(fp);
}
執行 hello!fflush（更新緩衝區）
相關函式 write，fopen，fclose，setbuf
表頭檔案 #include<stdio.h>
定義函式 int fflush(FILE* stream);
函式說明 fflush()會強迫將緩衝區內的資料寫回引數stream指定的檔案中。如果引數stream為NULL，fflush()會將所有開啟的檔案資料更新。
返回值 成功返回0，失敗返回EOF，錯誤程式碼存於errno中。
錯誤程式碼 EBADF 引數stream 指定的檔案未被開啟，或開啟狀態為只讀。其它錯誤程式碼參考write（）。
fileno（返回檔案流所使用的檔案描述詞）
相關函式 open，fopen
表頭檔案 #include<stdio.h>
定義函式 int fileno(FILE * stream);
函式說明 fileno()用來取得引數stream指定的檔案流所使用的檔案描述詞。
返回值 返回檔案描述詞。
#include<stdio.h>
main()
{
FILE * fp;
int fd;
fp=fopen(“/etc/passwd”,”r”);
fd=fileno(fp);
printf(“fd=%d/n”,fd);
fclose(fp);
}
執行 fd=36. 以二進位制形式讀取檔案中的資料
1． 函式原型：int fread(void *buffer,unsigned sife,unsigned count,FILE *fp)
2． 功能說明
從由fp指定的檔案中，按二進位制形式將sife*count個數據讀到由buffer指出的資料區中。
3． 引數說明
buffer：這是一個void型指標，指出要將讀入資料存放在其中的儲存區首地址。
sife：指出一個數據塊的位元組數，即一個數據塊的大小尺寸。
count：指出一次讀入多少個數據塊（sife）。
fp：這是個檔案指標，指出要從其中讀出資料的檔案。4．返回值
正常返回：實際讀取資料塊的個數，即count。
異常返回：如果檔案中剩下的資料塊個數少於引數中count指出的個數，或者發生了錯誤，返回0值。此時可以用feof()和ferror()來判定到底出現了什麼情況。
#include<stdio.h>
#define nmemb 3
struct test
{
char name[20];
int size;
}s[nmemb];
int main()
{
FILE * stream;
int i;
stream = fopen(“/tmp/fwrite”,”r”);
fread(s,sizeof(struct test),nmemb,stream);
fclose(stream);
for(i=0;i<nmemb;i++)
printf("name[%d]=%-20s:size[%d]=%d/n",i,s.name,i,s.size);
return 0;
}
執行結果：
name[0]=Linux! size[0]=6
name[1]=FreeBSD! size[1]=8
name[2]=Windows2000 size[2]=117. 以二進位制形式寫資料到檔案中去
1． 函式原型：int fwrite(void *buffer,unsigned sife,unsigned count,FILE *fp)
2． 功能說明
按二進位制形式，將由buffer指定的資料緩衝區內的sife*count個數據寫入由fp指定的檔案中去。
3． 引數說明
buffer：這是一個void型指標，指出要將其中資料輸出到檔案的緩衝區首地址。
sife：指出一個數據塊的位元組數，即一個數據塊的大小尺寸。
count：一次輸出多少個數據塊（sife）。
fp：這是個檔案指標，指出要從其中讀出資料的檔案。4．返回值
正常返回：實際輸出資料塊的個數，即count。
異常返回：返回0值，表示輸出結束或發生了錯誤。
#include <stdio.h>
#define SIZE 4
struct worker
{ int number;
char name[20];
int age;
};
void main()
{
struct worker wk;
int n;
FILE *in,*out;
if((in=fopen("file1.txt","rb"))==NULL)
{
printf("The file %s can not be opened.\n","file1.txt");
return;
}
if((out=fopen("file2.txt","wb"))==NULL)
{
printf("The file %s can not be opened.\n","file2.txt");
return;
}
while(fread(&wk,sizeof(struct worker),1,in)==1)
fwrite(&wk,sizeof(struct worker),1,out);
fclose(in);
fclose(out);
}示例程式碼：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define set_s(x,y) {strcpy(s[x].name,y);s[x].size=strlen(y);}
#define nmemb 3
struct test
{
char name[20];
int size;
}s[nmemb];
main()
{
FILE * stream;
set_s(0,"Linux!");
set_s(1,"FreeBSD!");
set_s(2,"Windows2000.");
stream=fopen("fwrite","w");
fwrite(s,sizeof(struct test),nmemb,stream);
fclose(stream);
}
執行 參考fread（）。8. 以二進位制形式讀取一個整數
1． 函式原型：int getw(FILE *fp)
2． 功能說明
從由fp指定的檔案中，以二進位制形式讀取一個整數。
3． 引數說明
fp：是檔案指標。
4． 返回值
正常返回：所讀取整數的值。
異常返回：返回EOF，即-1。由於讀取的整數值有可能是-1，所以必須用feof()或ferror()來判斷是到了檔案結束，還是出現了一個出錯。
#include <stdio.h>
void main(int argc,char *argv[])
{
int i,sum=0;
FILE *fp;
if(argc!=2)
{
printf("Command error,Usage: readfile filename\n");
exit(1);
}
if(!(fp=fopen(argv[1],"rb")))
{
printf("The file %s can not be opened.\n",argv[1]);
exit(1);
}
for(i=1;i<=10;i++) sum+=getw(fp);
printf("The sum is %d\n",sum);
fclose(fp);
}9. 以二進位制形式存貯一個整數
1．函式原型：int putw(int n,FILE *fp)
2． 功能說明
以二進位制形式把由變數n指出的整數值存放到由fp指定的檔案中。
3． 引數說明
n：要存入檔案的整數。
fp：是檔案指標。
4． 返回值
正常返回：所輸出的整數值。
異常返回：返回EOF，即-1。由於輸出的整數值有可能是-1，所以必須用feof()或ferror()來判斷是到了檔案結束，還是出現了一個出錯。
#include <stdio.h>
void main(int argc,char *argv[])
{
int i;
FILE *fp;
if(argc!=2)
{
printf("Command error,Usage: writefile filename\n");
return;
}
if(!(fp=fopen(argv[1],"wb")))
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
for(i=1;i<=10;i++) printf("%d\n", putw(i,fp));
fclose(fp);
}檔案狀態檢查
1. 檔案結束
（1） 函式原型：int feof(FILE *fp)
（2） 功能說明
該函式用來判斷檔案是否結束。
（3） 引數說明
fp：檔案指標。
（4） 返回值
0：假值，表示檔案未結束。
1：真值，表示檔案結束。
#include <stdio.h>
void main(int argc,char *argv[])
{
FILE *in,*out;
char ch;
if(argc!=3)
{
printf("Usage: copyfile filename1 filename2\n");
return;
}
if((in=fopen(argv[1],"rb"))==NULL)
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
if((out=fopen(argv[2],"wb"))==NULL)
{
printf("The file %s can not be opened.\n",argv[2]);
return;
}
while(!feof(in))
{
ch=fgetc(in);
if(ferror(in))
{
printf("read error!\n");
clearerr(in);
}
else
{
fputc(ch,out);
if(ferror(out))
{
printf("write error!\n");
clearerr(out);
}
}
}
fclose(in);
fclose(out);
}2. 檔案讀/寫出錯
（1） 函式原型：int ferror(FILE *fp)
（2） 功能說明
檢查由fp指定的檔案在讀寫時是否出錯。
（3） 引數說明
fp：檔案指標。
（4） 返回值
0：假值，表示無錯誤。
1：真值，表示出錯。
3. 清除檔案錯誤標誌
（1） 函式原型：void clearerr(FILE *fp)
（2） 功能說明
清除由fp指定檔案的錯誤標誌。
（3） 引數說明
fp：檔案指標。
（4） 返回值：無。
#include <stdio.h>
void main(int argc,char *argv[])
{
FILE *in,*out;
char ch;
if(argc!=3)
{
printf("Usage: copyfile filename1 filename2\n");
return;
}
if((in=fopen(argv[1],"rb"))==NULL)
{
printf("The file %s can not be opened.\n",argv[1]);
return;
}
if((out=fopen(argv[2],"wb"))==NULL)
{
printf("The file %s can not be opened.\n",argv[2]);
return;
}
while(!feof(in))
{
ch=fgetc(in);
if(ferror(in))
{
printf("read error!\n");
clearerr(in);
}
else
{
fputc(ch,out);
if(ferror(out))
{
printf("write error!\n");
clearerr(out);
}
}
}
fclose(in);
fclose(out);
}4. 瞭解檔案指標的當前位置
（1） 函式原型：long ftell(FILE *fp)
（2） 功能說明
取得由fp指定檔案的當前讀/寫位置，該位置值用相對於檔案開頭的位移量來表示。
（3） 引數說明
fp：檔案指標。
（4） 返回值
正常返回：位移量（這是個長整數）。
異常返回：-1，表示出錯。
（5） 例項
檔案定位
1. 反繞
（1） 函式原型：void rewind(FILE *fp)
（2） 功能說明
使由檔案指標fp指定的檔案的位置指標重新指向檔案的開頭位置。
（3） 引數說明
fp：檔案指標。
（4） 返回值：無。
#include <stdio.h>
void main()
{
FILE *in,*out;
in=fopen("filename1","r");
out=fopen("filename2","w");
while(!feof(in)) fputc(fgetc(in),out);
rewind(out);
while(!feof(in)) putchar(fgetc(in));
fclose(in);
fclose(out);
}
2. 隨機定位：移動檔案流的讀寫位置
（1） 函式原型：int fseek(FILE *fp,long offset,int base)
（2） 功能說明
使檔案指標fp移到基於base的相對位置offset處。
（3）引數說明
fp：檔案指標。
offset：相對base的位元組位移量。這是個長整數，用以支援大於64KB的檔案。
base：檔案位置指標移動的基準位置，是計算檔案位置指標位移的基點。ANSI C定義了base的可能取值，以及這些取值的符號常量。
（4）返回值
正常返回：當前指標位置。
異常返回：-1，表示定位操作出錯。
下列是較特別的使用方式:
1) 欲將讀寫位置移動到檔案開頭時:fseek(FILE *stream,0,SEEK_SET);
2) 欲將讀寫位置移動到檔案尾時:fseek(FILE *stream,0,0SEEK_END);
返回值 當呼叫成功時則返回0，若有錯誤則返回-1，errno會存放錯誤程式碼。
附加說明 fseek()不像lseek()會返回讀寫位置，因此必須使用ftell()來取得目前讀寫的位置。
#include <stdio.h>
#include <string.h>
struct std_type
{
int num;
char name[20];
int age;
char class;
}stud;
int cstufile()
{
int i;
FILE *fp;
if((fp=fopen("stufile","wb"))==NULL)
{
printf("The file can't be opened for write.\n");
return 0;
}
for(i=1;i<=100;i++)
{
stud.num=i;
strcpy(stud.name,"aaaa");
stud.age=17;
stud.class='8';
fwrite(&stud,sizeof(struct std_type),1,fp);
}
fclose(fp);
return 1;
}
void main()
{
int n;
FILE *fp;
if(cstufile()==0) return;
if((fp=fopen("stufile","rb"))==NULL)
{
printf("The file can not be opened.\n");
return;
}
for(n=0;n<100;n+=2)
{
fseek(fp,n*sizeof(struct std_type),SEEK_SET);
fread(&stud,sizeof(struct std_type),1,fp);
printf("%10d%20s%10d%4c\n",stud.num,stud.name,stud.age,stud.class);
}
fclose(fp);
}示例程式碼：
#include <stdio.h>
#include <stdlib.h>
#include<stdio.h>
void main()
{
FILE * stream;
long offset;
fpos_t pos;
stream=fopen(“/etc/passwd”,”r”);
fseek(stream,5,SEEK_SET);
printf("offset=%d/n",ftell(stream));
rewind(stream);
fgetpos(stream,&pos);
printf("offset=%d/n",pos);
pos=10;
fsetpos(stream,&pos);
printf("offset = %d/n",ftell(stream));
fclose(stream);
}
執行 結果
offset = 5
offset =0
offset=10ftell（取得檔案流的讀取位置）
相關函式 fseek，rewind，fgetpos，fsetpos
表頭檔案 #include<stdio.h>
定義函式 long ftell(FILE * stream);
函式說明 ftell()用來取得檔案流目前的讀寫位置。引數stream為已開啟的檔案指標。
返回值 當呼叫成功時則返回目前的讀寫位置，若有錯誤則返回-1，errno會存放錯誤程式碼。
錯誤程式碼 EBADF 引數stream無效或可移動讀寫位置的檔案流。
範例 參考fseek()。
關於exit()函式
1． 函式原型:void exit(int status)
2． 功能說明:exit()函式使程式立即終止執行，同時將緩衝區中剩餘的資料輸出並關閉所有已經開啟的檔案。
3． 引數說明:status：為0值表示程式正常終止，為非0值表示一個定義錯誤。
4． 返回值:無。
* 關於feof()函式
1． 函式原型:int feof(FILE *fp)
2． 功能說明
在文字檔案（ASCII檔案）中可以用值為-1的符號常量EOF來作為檔案的結束符。但是在二進位制檔案中-1往往可能是一個有意義的資料，因此不能用它 來作為檔案的結束標誌。為了能有效判別檔案是否結束，ANSI C提供了標準函式feof()，用來識別檔案是否結束。
3． 引數說明:fp：檔案指標。
4． 返回值
返回為非0值：已到檔案尾。
返回為0值：表示還未到檔案尾。
C語言的直接I\O檔案操作
這是 C 提供的另一種檔案操作，它是通過直接 存/取 檔案來完成對檔案的處理（也就是 系統呼叫。更多關於 系統呼叫 和 庫函式 可以參看 APUE《Advanced Programming in the Unix Environment》），而上面所說流式檔案操作是通過緩衝區來進行操作的（也就是通過庫函式（庫函式帶緩衝區，系統呼叫不帶緩衝區）來操作檔案）；流式檔案操作是圍繞一個FILE指標來進行，而此類檔案操作是圍繞一個檔案的“控制代碼”來進行，什麼是控制代碼呢？它是一個整數，是系統用來標識一個檔案(在WINDOWS中，控制代碼的概念擴充套件到所有裝置資源的標識)的唯一的記號。此類檔案操作常用的函式如下表，這些函式及其所用的一些符號在io.h和fcntl.h中定義，在使用時要加入相應的標頭檔案。
函式 說明
open() 開啟一個檔案並返回它的控制代碼
close() 關閉一個控制代碼
lseek() 定位到檔案的指定位置
read() 塊讀檔案
write() 塊寫檔案
eof() 測試檔案是否結束
filelength() 取得檔案長度
rename() 重新命名檔案
chsize() 改變檔案長度1.open()
開啟一個檔案並返回它的控制代碼，如果失敗，將返回一個小於0的值，原型是int open(const char *path, int access [, unsigned mode]); 引數path是要開啟的檔名，access是開啟的模式，mode是可選項。表示檔案的屬性，主要用於UNIX系統中，在DOS/WINDOWS這個引數沒有意義。其中檔案的開啟模式如下表。
符號 含義 符號 含義 符號 含義
O_RDONLY 只讀方式 O_WRONLY 只寫方式 O_RDWR 讀/寫方式
O_NDELAY 用於UNIX系統 O_APPEND 追加方式 O_CREAT 如果檔案不存在就建立
O_TRUNC 把檔案長度截為0 O_EXCL 和O_CREAT連用，如果檔案存在返回錯誤 O_BINARY 二進位制方式 O_TEXT 文字方式
對於多個要求，可以用"|"運算子來連線，如O_APPEND|O_TEXT表示以文字模式和追加方式開啟檔案。
例：inthandle=open("c:\\msdos.sys",O_BINARY|O_CREAT|O_WRITE)
2.close()
關閉一個控制代碼，原型是int close(int handle);如果成功返回0
例：close(handle)
3.lseek()
定位到指定的位置，原型是：long lseek(int handle,long offset, int fromwhere);引數offset是移動的量，fromwhere是移動的基準位置，取值和前面講的fseek()一樣，SEEK_SET：檔案首部；SEEK_CUR：檔案當前位置；SEEK_END：檔案尾。此函式返回執行後文件新的存取位置。
例：
lseek(handle,-1234L,SEEK_CUR);//把存取位置從當前位置向前移動1234個位元組。
x=lseek(hnd1,0L,SEEK_END);//把存取位置移動到檔案尾，x=檔案尾的位置即檔案長度
4.read()
從檔案讀取一塊，原型是int read(int handle, void*buf, unsigned len);引數buf儲存讀出的資料，len是讀取的位元組。函式返回實際讀出的位元組。
例：char x[200];read(hnd1,x,200);
5.write()
寫一塊資料到檔案中，原型是int write(int handle,void *buf, unsigned len);引數的含義同read()，返回實際寫入的位元組。
例：char x[]="I LoveYou";write(handle,x,strlen(x));
7.eof()
類似feof()，測試檔案是否結束，是返回1，否則返回0;原型是：inteof(int handle);
例：while(!eof(handle1)){……};
8.filelength()
返回檔案長度，原型是long filelength(int handle);相當於lseek(handle,0L,SEEK_END)
例：long x=filelength(handle);
9.rename()
重新命名檔案，原型是int rename(const char*oldname, const char *newname); 引數oldname是舊檔名，newname是新檔名。成功返回0
例：rename("c:\\config.sys","c:\\config.w40");
10.chsize();
改變檔案長度，原型是int chsize(int handle, longsize);引數size表示檔案新的長度，成功返回0，否則返回-1，如果指定的長度小於檔案長度，則檔案被截短；如果指定的長度大於檔案長度，則在檔案後面補''\0''。
例：chsize(handle,0x12345);
如果熟悉彙編可能會發現這種方式和組合語言的DOS功能呼叫控制代碼式檔案操作很像，比如open()就像DOS服務的3CH號功能呼叫，其實這種操作還有兩種型別的函式就是直接用DOS功能來完成的，如_open()，_dos_open()等等。有興趣可自已查詢BCB的幫助。
同流式檔案操作相同，這種也提供了Unicode字元操作的函式，如_wopen()等等，用於9X/NT下的寬字元程式設計，有興趣可自已查詢BCB的幫助。
另外，此種操作還有lock(),unlock(),locking()等用於多使用者操作的函式，但在BCB中用得並不多，我就不介紹了，但如果要用C來寫CGI，這些就必要的常識了，如果你有這方面的要求，那就得自已好好看幫助了.
setbuffer（設定檔案流的緩衝區）
相關函式 setlinebuf，setbuf，setvbuf
表頭檔案 #include<stdio.h>
定義函式 void setbuffer(FILE * stream,char * buf,size_t size);
函式說明 在開啟檔案流後，讀取內容之前，呼叫setbuffer()可用來設定檔案流的緩衝區。引數stream為指定的檔案流，引數buf指向自定的緩衝區起始地址，引數size為緩衝區大小。
返回值
setlinebuf（設定檔案流為線性緩衝區）
相關函式 setbuffer，setbuf，setvbuf
表頭檔案 #include<stdio.h>
定義函式 void setlinebuf(FILE * stream);
函式說明 setlinebuf()用來設定檔案流以換行為依據的無緩衝IO。相當於呼叫:setvbuf(stream,(char * )NULL,_IOLBF,0);請參考setvbuf()。
返回值
setvbuf（設定檔案流的緩衝區）
相關函式 setbuffer，setlinebuf，setbuf
表頭檔案 #include<stdio.h>
定義函式 int setvbuf(FILE * stream,char * buf,int mode,s