下面這篇文件寫的還是挺有深度的，收藏
最近實在是太忙了，這篇整整就推遲了1個月了，實在是對不起。之前本打算這個模塊就結束了，文件操作就不寫了，但是文件操作又是一個很重要的東西，而且也剛好能夠總結之前我們學習的所有知識。同時也爲了將文件操作這個初學者認爲很神祕的東西給本質化。因此，本篇將逐一介紹C語言的文件操作。（本模塊的命名本來是想C/C++一塊兒講解的，但是由於工作、畢業論文、業餘時間的充電、還有要完成那個未知的夢等，因此因爲時間問題C++就只能放在以後有機會再寫了，因此本篇將是本模塊的最後一篇，之後將不會再連載了，請大家諒解。）
好了，回到正題，先來看文件操作中的文件。所謂文件（file）一般指存儲在外部介質上數據的集合，比如我們經常使用的mp3、mp4、txt、bmp、jpg、exe、rmvb等等。這些文件各有各的用途，我們通常將它們存放在磁盤或者可移動盤等介質中。那麼，爲什麼這裏面又有這麼多種格式的文件呢？原因很簡單，它們各有各的用途，區分就在於這些文件裏面存放的數據集合所遵循的存儲規則不一樣。舉個例子比如bmp圖片文件，爲什麼他能夠表示一張圖片，因爲它有固定的格式，哪一段到哪一段，哪個偏移到哪個偏移應該存放什麼數據是規定好了的。比如有文件頭，一般是一個結構體，存放的文件的一些信息，如圖片的大小，像素等等。再後來有數據區。然後我們要顯示一張圖片，就只需要按照前面所說的規則將文件頭結構和數據塊讀出來，然後將這些數據在屏幕上用顏色表示出來，就成了一張圖片。其它文件格式也類似。
這裏要說一個更重要的例子，對我們理解文件有好處。那麼這個文件就是exe文件（這裏只討論windows平臺），通常我們認爲它是一個可執行程序，這無疑是增加了它的神祕度。從本質上來講exe無非是一種固定的文件格式罷了。既然這樣，它就有一套自己的存儲規則。跟前面的圖片文件一樣有規則。此時，你可能會問：你這麼說那我就可以純手工（直接填寫數據填充文件）寫出一個exe可執行文件了？ 面對你這個問題，我只能說你已經習慣思考了，已經習慣給自己提問了，已經很聰明瞭。那麼答案是肯定的，你完全可以用一個編輯器直接填寫數據寫出一個helloworld.exe文件或者helloworld.dll文件。因爲這些具有一定格式規則的文件一般是二進制存儲的，於是我們可以用一個二進制編輯器新建一個二進制文件，然後向裏面填寫數據。然後雙擊運行輸出“helloworld”字符串。你可能會覺得很有成就感，我之前就寫過一個exe和dll。這裏exe和dll的文件格式也就是著名的PE文件格式。有興趣你可以去查閱相關資料，此非本文重點。
總結上面的認識，文件無非就是一段數據的集合，這些數據可以是有規則的集合，也可以是無序的集合。操作系統也就是以文件爲單位對數據進行管理的。也就是說，要訪問外部介質上的數據，必須先按照文件名進行查找，然後從該文件中讀取數據。要想寫數據到外部介質，必須得建立一個文件，然後再寫入。因此，這樣來看，你眼前的文件將是一堆一堆數據而已，也沒有什麼類型文件之分了，類型只是爲了區分而已，假如你把一個exe文件的擴展名改爲txt，把它用記事本打開，同樣是可行的，只是會執行exe文件裏面的東西而已。（這裏又不得不提到一點，如果你是一名程序員或者愛好者，那麼你不應該將你的文件擴展名給隱藏了，要讓它顯示出來，如果你隱藏了，無非是增加了它的神祕感，同時在文件操作上不方便。通過上面的本質，我相信你能體會到我爲什麼這麼說。）
說到這裏，你應該知道文件是什麼了，那麼再來看二進制文件和ASCII文本文件，爲什麼要分爲這兩種呢？
首先、文本文件方式存儲多用於我們需要明顯知道文件裏面的內容時，比如ini、h、c等文件都是文本文件，這種文件存儲的是字符（ASCII碼），比如一個整數10000，類型是short，佔2字節，存儲文本形式將佔用5個字節，一共5個字符。你可以想想更多的例子，體會文本文件方便之處（提示：這裏的文本文件不是說是txt文件，而是指所有以文本格式存儲的文件。）
其次、二進制文件方式多用於直接將內存裏面的數據形式原封不動存放到文件裏，比如上面的short 10000，在內存中佔2字節，存儲內容爲10000的二進制數，存到文件後還是佔2字節，內容也是10000的二進制。這種方式可以整塊數據一塊兒存儲，同時還可以將內存數據映射到文件裏。
由上面兩點，C語言操作文件可以是字節流或者二進制流。它把數據看成是一連串字符（字節），而不需要考慮邊界。C語言對文件的存取是以字節爲單位的。輸入輸出的數據流的開始和結束僅受程序控制而不受物理符號（如回車換行符）控制。這種文件通常稱爲流式文件，大大增加了靈活性。我們可以產生很多自己的文件格式，在遊戲程序裏面，用得比較多的就是資源包的格式，一般就是自定義的存取規則。我之前也寫了一個包文件，存取只需要遵循規則，原理是非常簡單的。大家可以試試在腦子裏面構造一個包文件。
在ANSI C標準中，使用的是“緩衝文件系統”。所謂緩衝文件系統指系統自動地在內存區爲每一個正在使用的文件名開闢一個緩衝區，從內存向磁盤輸出數據必須先送到內存中的緩衝區，裝滿後再一起送到磁盤去。反向也是如此。這裏需要說明兩個詞：“輸入”“輸出”。輸入表示從文件裏讀數據到程序裏，輸出表示從程序裏寫數據到文件中。
瞭解了文件及文件存儲形式，下面該正式進入文件的讀寫了，不要太激動，還是慢慢來。細節往往決定成敗。在緩衝文件系統中，有一個很重要的一個東西就是文件指針，每個使用的文件都會在內存中開闢一個區，用於存放文件的有關信息，這些文件信息就保存在一個結構體變量中的，這個結構體是由系統定義的，名爲FILE，先來看看VC2005在stdio.h下FILE結構體的定義：
struct _iobuf
{
char *_ptr; // 指向buffer中第一個未讀的字節
int _cnt; // 記錄剩餘未讀字節的個數
char *_base; // 指向一個字符數組，即這個文件的緩衝
int _flag; // FILE結構所代表的打開文件的一些屬性
int _file; // 用於獲取文件描述，可以使用fileno函數獲得此文件的句柄。
int _charbuf; // 單字節的緩衝，即緩衝大小僅爲1個字節，如果爲單字節緩衝，_base將無效
int _bufsiz; // 記錄這個緩衝的大小
char *_tmpfname; // temporary file (i.e., one created by tmpfile()
// call). delete, if necessary (don't have to on
// Windows NT because it was done by the system when
// the handle was closed). also, free up the heap
// block holding the pathname.
};
typedef struct _iobuf FILE;
好了，上面的結構體就是這樣定義的。這裏不得不再次提到緩衝：
|
緩衝模式 |
常量(mode) |
備註 |
|
無緩衝模式 |
_IONBF |
該文件不使用任何緩衝，也可以說是字節緩衝 只能保存一個字節。 |
|
行緩衝模式 |
_IOLBF |
僅對文本模式打開的文件有效，所謂行，即是指每收到一個換行符(/n或/r/n)，就將緩衝flush掉 |
|
全緩衝模式 |
_IOFBF |
僅當緩衝滿時才進行flush |
上面結構體中的_flag就標記了緩衝的信息（我們關心這三個）：
#define _IOYOURBUF 0x0100 // 使用用戶通過setbuf提供的buffer
#define _IOMYBUF 0x0008 // 這個文件使用內部的緩衝
#define _IONBF 0x0004 // 無緩衝模式
#define _IOLBF 0x0040 // 行緩衝模式
#define _IOFBF 0x0000 // 全緩衝模式
同時，_flag也標記了讀寫模式，比如"r+"、"w+"等。
#define _IOREAD 0x0001 // 只讀
#define _IOWRT 0x0002 // 只寫
#define _IORW 0x0080 // 可讀可寫
上面的3中模式就是"r"、"w"、"+"任意組合起來表示的意思。
正因爲使用緩衝模式，是爲了避免頻繁的系統調用開銷，有了緩衝就不需要每次都訪問實際的文件。當然緩衝也會帶來隱患，比如寫文件時，先是到緩衝，如果此時系統崩潰或者進程意外退出時，有可能導致文件數據的丟失。因此C語言提供了幾個基本的函數，彌補緩衝帶來的問題：
int fflush( FILE* stream ) // flush指定文件的緩衝，若參數爲NULL，則flush所有文件的緩衝。
int setvbuf( FILE *stream, char* buf, int mode, size_t size ) // 設定緩衝類型，如上面的表格。
void setbuf( FILE* stream, char* buf ) // 設置文件的緩衝，等價於( void )setvbuf( stream, buf, _IOFBF, BUFSIZ ).
所謂flush一個緩衝，是指對寫緩衝而言，將緩衝內的數據全部寫入實際的文件，並將緩衝清空，這樣可以保證文件處於最新的狀態。之所以需要flush，是因爲寫緩衝使得文件處於一種不同步的狀態，邏輯上一些數據已經寫入了文件，但實際上這些數據仍然在緩衝中，如果此時程序意外地退出（發生異常或斷電等），那麼緩衝裏的數據將沒有機會寫入文件。flush可以在一定程度上避免這樣的情況發生。
在這個表中我們還能看到C語言支持兩種緩衝，即行緩衝（Line Buffer）和全緩衝（Full Buffer）。全緩衝是經典的緩衝形式，除了用戶手動調用fflush外，僅當緩衝滿的時候，緩衝纔會被自動flush掉。而行緩衝則比較特殊，這種緩衝僅用於文本文件，在輸入輸出遇到一個換行符時，緩衝就會被自動flush，因此叫行緩衝。
終於把概念性的東西和準備步驟做完了，下面該看看具體的讀寫文件了。有了前面的準備工作，讀寫文件將不是難事了，因爲有現成的庫函數供我們使用，我們下面的段落將是如何使用這些庫函數和一些注意事項而已了。
首先看如何打開文件，先看代碼：
#include <stdio.h>
int main( void )
{
FILE* pReadFile = fopen( "E://mytest.txt", "r" ); // 打開文件
if ( pReadFile == NULL )
return 0;
fclose( pReadFile ); // 關閉文件
return 0;
}
上面的這段代碼，只是一個簡單的打開文件，如果成功打開後直接關閉。這裏打開的是一文本文件，是以只讀的方式打開。使用fopen函數打開，第一個參數是文件路徑，第二個參數是讀寫模式，返回值爲0表示打開失敗。先看看讀寫模式：
|
文件使用方式 |
含義 |
|
"r"(只讀) |
爲輸入打開一個文本文件，不存在則失敗 |
|
"w"(只寫) |
爲輸出打開一個文本文件，不存在則新建，存在則刪除後再新建 |
|
"a"(追加) |
向文本文件尾部增加數據，不存在則創建，存在則追加 |
|
'rb"(只讀) |
爲輸入打開一個二進制文件，不存在則失敗 |
|
"wb"(只寫) |
爲輸入打開一個二進制文件，不存在則新建，存在則刪除後新建 |
|
"ab"(追加) |
向二進制文件尾部增加數據，不存在則創建，存在則追加 |
|
"r+"(讀寫) |
爲讀寫打開一個文本文件，不存在則失敗 |
|
"w+" (讀寫) |
爲讀寫建立一個新的文本文件，不存在則新建，存在則刪除後新建 |
|
"a+"(讀寫) |
爲讀寫打開一個文本文件，不存在則創建，存在則追加 |
|
"rb+"(讀寫) |
爲讀寫打開一個二進制文件，不存在則失敗 |
|
"wb+"(讀寫) |
爲讀寫建立一個新的二進制文件，不存在則新建，存在則刪除後新建 |
|
"ab+"(讀寫) |
爲讀寫打開一個二進制文件，不存在則創建，存在則追加 |
一、讀寫字符
C語言爲從文件中讀寫一個字符提供了兩個函數：
int __cdecl fgetc( FILE* stream ); // 從文件讀入一個字符
int __cdecl fputc( int ch, FILE* stream ); // 寫入一個字符到文件
看例子：
#include <stdio.h>
int main( void )
{
char cInput;
FILE* pReadFile = fopen( "E://mytest.txt", "r" ); // 打開文件
if ( pReadFile == NULL )
return 0;
while ( ( cInput = fgetc( pReadFile ) ) != EOF ) // 從文件讀入一個字符，如果到文件尾部，則返回EOF（-1）
printf( "%c", cInput );
fclose( pReadFile ); // 關閉文件
return 0;
}
假如mytest.txt文件的內容是：
masefee
hello
world
三行，那麼我們逐個讀入每個字符，直到EOF結束，EOF很簡單，其實就是#define EOF (-1)，WINDOWS爲了能夠返回失敗爲-1，因此fgetc的返回值使用是int類型。同時-1也不是某個字符的ASCII，所以不影響，一舉兩得。上面程序while循環不斷從文件中讀取單個字符，遇到換行符(WINDOWS下回車符('/r')爲13， 換行符('/n')爲10)，printf輸出後變處理成換行符了，因此文件裏面3行，逐個讀入程序裏在終端顯示後還是3行。代碼很簡單，就不用多說了。這裏需要提到一點：
問題一：當第一次執行了fgetc後，我們看看pReadFile指針裏面的內容與剛執行了fopen函數後的內容有所變化，爲什麼？
再來看fputc函數：
#include <stdio.h>
int main( void )
{
int i = 0;
char szOutput[ 32 ] = "masefee/nhello";
FILE* pWriteFile = fopen( "E://mytest.txt", "w" ); // 打開文件
if ( pWriteFile == NULL )
return 0;
while ( szOutput[ i ] != 0 )
{
fputc( szOutput[ i ], pWriteFile ); // 寫入一個字符到文件
i++;
}
fclose( pWriteFile ); // 關閉文件
return 0;
}
我特意在szOutput數組裏寫了一個'/n'字符，此字符就是換行符newline，意圖是當輸出到e之後，便輸出一個換行符，讓字符串換行。因此最終mytest.txt文件裏面的內容如下：
masefee
hello
到這裏，你可能會想到第一個fgetc的例子是我們預先在文件中輸入3行字符，然後讀入到程序中。我們在用記事本輸入3行文本的時候，每當換行的時候我們敲鍵盤是按的回車。
問題二：既然我們敲的是回車，爲什麼在文件裏存儲的是'/n'而不是'/r'？
同時，到這裏想到第一個問題，我們又來觀察一下，當剛使用fopen函數時，pWriteFile裏面的內容是：
pWriteFile 0x00437bb0
_ptr 0x00000000
_cnt 0
_base 0x00000000
_flag 2
_file 3
_charbuf 0
_bufsiz 0
_tmpfname 0x00000000
而執行了fputs函數，到換行符後我們再看pWriteFile裏面的內容：
pWriteFile 0x00437bb0
_ptr 0x00385019
_cnt 4087
_base 0x00385010
_flag 10
_file 3
_charbuf 0
_bufsiz 4096
_tmpfname 0x00000000
然後我們再看看_base所在內存的值：
6d 61 73 65 66 65 65 0a 68
m a s e f e e /n h
從這個現象我們能夠意識到，FILE結構裏面_base所指向的緩衝區，_cnt表示還剩下多少個字節沒有寫。還可以意識到，我們在不設置任何參數時，默認情況下是採用的全緩衝模式，填充4096字節後自動會寫入到文件，在這裏我們沒有那麼多字節，因此在fclose函數執行後，文件裏便寫入了值。你可以打斷點在fclose上，等程序斷下來後，觀察你磁盤裏面的mytest.txt是空的，當執行了fclose後大小就變了。這也能體現緩衝區的一個現象。
同樣，如果你想立即將緩衝區的數據寫到文件裏，可以在fclose函數前面加上：
fflush( pWriteFile );
當執行完此函數後，數據便寫進了文件，最後再關閉文件。
二、讀寫字符串
C語言爲從文件中讀寫字符串提供了2個函數：
char* __cdecl fgets( char* _Buf, int _MaxCount, FILE* _File );
參數一：要從文件中讀入字符串的存放空間。
參數二：最大讀取字節數。
參數三：文件指針。
返回值：返回讀入的字符串指針。
int __cdecl fputs( const char* _Str, FILE* _File );
參數一：要寫入文件的字符串
參數二：文件指針
返回值：失敗或成功，0表示成功，其它表示失敗。
先來看字符串讀取：
#include <stdio.h>
int main( void )
{
char szInput[ 32 ] = { 0 };
char* pRet = NULL;
FILE* pReadFile = fopen( "E://mytest.txt", "r" ); // 打開文件
if ( pReadFile == NULL )
return 0;
pRet = fgets( szInput, 32, pReadFile ); // 從文件中讀取一個字符串到szInput數組中
fclose( pReadFile ); // 關閉文件
return 0;
}
其它函數不說了，這裏只說fgets函數，第二個參數傳的是32，實際只能從文件中讀取31個字符，因爲fgets函數內部會將最後一個字符置爲'/0', 表示字符串結束。那麼我們可以看看fgets函數的內部原理，我這裏寫寫僞代碼，爲了更清晰的表現出來：
char* fgets( char* dst, int maxcount, FILE* file )
{
char ch;
while( --maxcount )
{
ch = readFromFile();
if ( ( *dst++ = ch ) == '/n' )
break;
}
*dst = 0; // 賦值爲'/0'
return dst;
}
紅色部分是計數，藍色部分是關鍵，如果最大讀取字節數量足以讀到換行，將停止讀取字符，然後階數本字符串，然後返回。
明白了fgets函數，fputs函數就簡單了：
#include <stdio.h>
int main( void )
{
char szOutput[ 32 ] = "masefee/nhello";
FILE* pWriteFile = fopen( "E://mytest.txt", "w" ); // 打開文件
if ( pWriteFile == NULL )
return 0;
fputs( szOutput, pWriteFile ); // 寫入一個字符串到文件
fclose( pWriteFile ); // 關閉文件
return 0;
}
這裏我也專門爲字符數組裏增加了一個換行符，寫入字符串的時候並不會因爲換行符而只寫換行符前面的字符，同時在fputs內部會求第一個參數的長度strlen( Str ); 然後再寫入這麼一個長度的字符串到文件。
到這裏又得提醒一點，即便是文件裏面含有'/0'（ASCII碼爲0的字符）。fgets函數同樣會一直讀取到換行符或者讀取規定的字符個數（此字符個數小於一行字符數）。雖然是讀了一行，中間因爲有0，因此字符串被截斷，讀出來的字符串並沒有一行，只有0前面的所有字符。這裏大家需要注意。同時fputs函數會以0結束寫入文件，這是跟通常情況一樣的，可以不用關心。
三、格式化數據讀寫
C語言既然有printf、scanf，那麼同樣也有文件操作的格式化函數：
int __cdecl fprintf( FILE* _File, const char* _Format, ... );
int __cdecl fscanf( FILE* _File, const char* _Format, ... );
這兩個函數跟printf和scanf的用法非常相似，只是這裏輸入輸出是關於文件的。
直接貼代碼：
#include <stdio.h>
typedef struct SStudent
{
int number;
char name[ 11 ];
}Student;
int main( void )
{
Student stu;
FILE* pReadFile = fopen( "E://mytest.txt", "r" ); // 打開文件
if ( pReadFile == NULL )
return 0;
fscanf( pReadFile, "%d%s", &stu.number, &stu.name );
fclose( pReadFile ); // 關閉文件
return 0;
}
我定義了一個結構體，裏面一個學號，一個姓名。然後打開文件，讀取數據到stu結構體變量中。假如文件中是：
345 masefee
346 Tim
然後讀到stu結構體變量中，number爲345，name爲"masefee"。
fscanf讀取數據是以空格、製表符、換行符進行分割的，我們可以這樣來填充結構體。
再來看fprintf：
#include <stdio.h>
typedef struct SStudent
{
int number;
char name[ 11 ];
}Student;
int main( void )
{
Student stu;
FILE* pWriteFile = fopen( "E://mytest.txt", "w" ); // 打開文件
if ( pWriteFile == NULL )
return 0;
stu.number = 100;
strcpy( stu.name, "masefee" );
fprintf( pWriteFile, "%d %s", stu.number, stu.name );
fclose( pWriteFile ); // 關閉文件
return 0;
}
此程序將把結構體stu的內容寫到文件裏，注意這裏的name不會把結束符'/0'寫到文件裏。
好了，說到這裏，上面幾個基本的文件操作函數已經寫完了，我只是使用了"r"和"w"兩種方式，其它方式你可以自行測試，也沒有什麼特別的。如果你是用上面的函數去讀取二進制序列，也是沒有錯的，只不過你更不好控制而已。至於和"+"組合也沒有什麼特別的，無非就是在文件尾部追加，原理一樣，大家可以自行測試。
四、文件數據塊讀寫
同樣C語言也提供了兩個函數：
size_t __cdecl fwrite
(
const void *buffer, // 要寫入文件的數據塊
size_t size, // 寫入文件的字節數
size_t count, // 寫入count個size大小的數據
FILE *stream // 文件指針
);
size_t __cdecl fread
(
void * _DstBuf, // 存放從文件讀出來的數據
size_t _ElementSize, // 讀取字節數
size_t _Count, // 讀入次數
FILE * _File // 文件指針
);
先看看fwrite函數：
#include <stdio.h>
typedef struct SStudent
{
int number;
char name[ 12 ];
}Student;
int main( void )
{
Student stu;
FILE* pWriteFile = fopen( "E://mytest.txt", "w" ); // 打開文件
if ( pWriteFile == NULL )
return 0;
stu.number = 10000;
strcpy( stu.name, "masefee" );
fwrite( &stu, sizeof( stu ), 1, pWriteFile );
fclose( pWriteFile ); // 關閉文件
return 0;
}
這樣寫入文件後，mytest.txt的內容爲：
' masefee 燙燙
你可能會疑惑，爲什麼會有亂碼？而且還有可惡的“燙”字。原因很簡單，fwrite函數是以數據塊的形式寫數據到文件的，比如這裏的stu結構體變量，我們將它整塊寫入文件，一共16字節，因此上面的亂碼對應的就是stu結構體變量在內存中的存放形式，number佔4字節，name佔12字節，具體的數值是：
10 27 00 00 6d 61 73 65 66 65 65 00 cc cc cc cc
10000 "masefee" 燙 燙
因爲我們在爲name拷貝字符串時，並沒有將name的所有字符清零，因此係統默認初識化爲0xcc，爲什麼初始化爲0xcc，之前我應該提過，主要是這個0xcc是彙編中斷指令的機器碼，主要防止訪問越解釋，進行中斷報錯。而0xcccc就是中文編碼的“燙”字。
最後面的兩個“燙”還不能省略，因爲我們是以塊寫入文件的，如果去掉4個cc，那麼將沒有16字節，如果有多個結構體變量的數據一塊兒寫到文件中時，結構體的數據對齊是非常重要的，否則將讀寫越界，跟內存一樣。這裏就好比內存的一個映射。
至於爲什麼會出現亂碼，是因爲超過可現實ASCII碼值，看上去就是亂的，其實數據還是正常的。
理解了fwrite函數後，fread函數就簡單了，由於篇幅原因我這裏只寫關鍵：
Student stu_out;
fread( &stu_out, sizeof( Student ), 1, pReadFile );
這樣就能填充好stu_out結構體變量，我想你已經體會到了數據塊讀寫時，數據對齊的重要性了。在遊戲的資源包，就是採用的數據塊的存儲形式，同時bmp、jpg、exe、dll等文件都是由很多個數據塊，通常是結構體的形式直接寫入文件的，這樣文件頭記錄了很多偏移，很多大小等就顯得非常重要了。
最後，我直接寫了一個實例，就是簡單的打包，解包程序。可以將多個文件放置到一個包文件裏，這個包是二進制包。基本的功能已經實現，只需要添加比如壓縮，界面等優化工作了。我初步測試了一下是可以成功打包解包的，也沒有太多的條件檢查和效率考慮，本文重在解釋文件操作的靈活性和重要性。好了，直接上代碼吧：
- #include <stdio.h>
- #include <string.h>
- #include <stdlib.h>
- typedef unsigned int uint;
- typedef unsigned char byte;
- // 包文件中最大可容納的文件個數
- #define MAX_FILE_COUNT 10
- // 全局包文件指針
- FILE* g_pMasFile = NULL;
- // 資源包文件頭結構
- typedef struct SMaseFileHeader
- {
- uint uFileFlag; // 包文件頭標記: 'MASE'
- uint uFileCount; // 包內文件個數
- uint uFileListOfs; // 文件列表偏移
- uint uMaxFileCount; // 最大子文件個數
- uint uFileSize; // 包文件的大小
- }MaseHeader;
- // 包內文件信息結構
- typedef struct SFilesMessage
- {
- uint uFileOfs; // 本文件在包內的偏移
- uint uFileSize; // 本文件的大小
- char szFileName[ 260 ]; // 本文件的路徑
- }FilesMsg;
- // 打開包文件
- int OpenMasFile( const char* path, const byte onlyOpen )
- {
- uint uWriteCount; // 寫入文件信息次數；
- byte bIsNew = 0; // 是否新建的
- MaseHeader header; // 文件頭結構定義
- FilesMsg msg;
- g_pMasFile = fopen( path, "rb" ); // 用來判斷是否存在
- if ( g_pMasFile == NULL ) // 這裏就沒有用windows API了
- {
- if ( onlyOpen == 1 ) // 只打開不新建
- return -1;
- bIsNew = 1;
- g_pMasFile = fopen( path, "wb" );
- if ( g_pMasFile == NULL )
- return -1;
- }
- // 先關閉，然後在用"rb+"方式打開
- fclose( g_pMasFile );
- g_pMasFile = fopen( path, "rb+" );
- if ( g_pMasFile == NULL )
- return -1;
- if ( bIsNew == 1 ) // 新建的文件
- {
- header.uFileFlag = 'ESAM';
- header.uFileCount = 0;
- header.uFileListOfs = sizeof( MaseHeader ); // 緊跟着就是文件列表
- header.uMaxFileCount = MAX_FILE_COUNT;
- header.uFileSize = sizeof( MaseHeader )
- + ( MAX_FILE_COUNT * sizeof( FilesMsg ) );
- // 寫入頭信息
- fwrite( &header, sizeof( MaseHeader ), 1, g_pMasFile );
- memset( &msg, 0, sizeof( FilesMsg ) );
- uWriteCount = MAX_FILE_COUNT;
- // 寫入文件列表用0佔位
- while( uWriteCount-- )
- fwrite( &msg, sizeof( FilesMsg ), 1, g_pMasFile );
- }
- else // 文件存在
- {
- // 則讀取頭文件信息
- fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );
- }
- // 檢查文件頭標記
- if ( header.uFileFlag != 'ESAM' )
- {
- fclose( g_pMasFile );
- return -1;
- }
- // 檢查數據是否完整
- if ( header.uMaxFileCount != MAX_FILE_COUNT )
- {
- fclose( g_pMasFile );
- return -1;
- }
- return 0;
- }
- // 寫文件到包裏
- int WriteFileToPak( const char* path )
- {
- FilesMsg fileMsg; // 此文件的文件信息結構
- MaseHeader header; // 包文件頭結構定義
- uint uFileSize;
- uint uFileListEndOfs;
- byte* pBuff;
- FILE* pFile = NULL;
- if ( g_pMasFile == NULL )
- return -1;
- memset( &fileMsg, 0, sizeof( FilesMsg ) );
- fseek( g_pMasFile, 0, SEEK_SET );
- // 則讀取頭文件信息
- fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );
- uFileListEndOfs = header.uFileCount * sizeof( FilesMsg ) + header.uFileListOfs;
- pFile = fopen( path, "rb" );
- if ( pFile == NULL )
- return -1;
- fseek( pFile, 0, SEEK_END );
- uFileSize = ftell( pFile );
- fseek( pFile, 0, SEEK_SET );
- // 文件名長度不能超過260
- strcpy( fileMsg.szFileName, path );
- fileMsg.uFileOfs = header.uFileSize;
- fileMsg.uFileSize = uFileSize;
- // 寫入文件信息
- // 將文件指針定位到uFileListEndOfs處，以便寫入新的文件信息結構
- fseek( g_pMasFile, uFileListEndOfs, SEEK_SET );
- fwrite( &fileMsg, sizeof( FilesMsg ), 1, g_pMasFile );
- // 申請空間
- pBuff = ( byte* )malloc( uFileSize );
- fread( pBuff, uFileSize, 1, pFile );
- // 寫數據到包文件裏
- fseek( g_pMasFile, header.uFileSize, SEEK_SET );
- fwrite( pBuff, uFileSize, 1, g_pMasFile );
- // 釋放內存
- free( pBuff );
- // 重新填充header
- header.uFileCount += 1;
- header.uFileSize += uFileSize;
- fseek( g_pMasFile, 0, SEEK_SET );
- // 重新寫入包文件頭
- fwrite( &header, sizeof( MaseHeader ), 1, g_pMasFile );
- return 0;
- }
- // 從包文件裏讀數據
- int ReadFileFromPak( const FilesMsg msg, byte* _dst )
- {
- if ( g_pMasFile == NULL )
- return -1;
- fseek( g_pMasFile, msg.uFileOfs, SEEK_SET );
- fread( _dst, msg.uFileSize, 1, g_pMasFile );
- return 0;
- }
- // 獲取包中某個文件的信息
- int GetFileMessage( const char* path, FilesMsg* msg )
- {
- FilesMsg fileMsg; // 此文件的文件信息結構
- MaseHeader header; // 包頭結構
- uint uFileCount; // 文件個數
- if ( g_pMasFile == NULL || msg == NULL )
- return -1;
- // 則讀取頭文件信息
- fseek( g_pMasFile, 0, SEEK_SET );
- fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );
- uFileCount = header.uFileCount;
- while ( uFileCount-- )
- {
- fread( &fileMsg, sizeof( FilesMsg ), 1, g_pMasFile );
- // 判斷是否是要獲取的文件
- if ( stricmp( fileMsg.szFileName, path ) == 0 )
- {
- *msg = fileMsg;
- return 0;
- }
- }
- return -1;
- }
- // 關閉包文件
- int CloseMasFile( void )
- {
- if ( g_pMasFile == NULL )
- return -1;
- fclose( g_pMasFile );
- g_pMasFile = NULL;
- return 0;
- }
上面已經將整個打包解包接口給實現了，我自定義文件擴展名爲.mase, 這個隨意哈，文件頭結構上面已經很清晰了。由於篇幅的原因，這裏就不一一解說了，我貼了很多註釋。應該能夠看懂的。
有了上面的接口，我們就可以來操作這個包文件了，先是看怎麼寫入：
- int main( void )
- {
- int ret;
- ret = OpenMasFile( "E://PhotoPak.mase", 0 );
- if ( ret == -1 )
- goto __exit;
- WriteFileToPak( "E://大山.jpg" );
- WriteFileToPak( "E://海水.bmp" );
- WriteFileToPak( "E://查看.exe" );
- WriteFileToPak( "E://加載.dll" );
- WriteFileToPak( "E://說明.txt" );
- __exit:
- CloseMasFile();
- return 0;
- }
在這段代碼裏，演示了怎麼將文件給寫進包文件，首先是創建了一個PhotoPak.mase包，然後是向裏面寫入了：大山.jpg、海水.bmp、查看.exe、加載.dll、說明.txt這麼幾個文件，注意我的接口裏面都是用二進制打開的，因爲如果是非二進制打開的話，寫入的時候會插入一些物理字符（比如回車符（ASCII：0x0D( 1310 )）等）。那樣插入進去後，然後在解包時再採用非二進制方式寫入文件就不是原來的文件了，這點大家要注意。
好了，寫了這麼幾個文件後，再看看怎麼把他們從包裏面弄出來，然後能夠正常的打開和查看：
- int main( void )
- {
- byte* pBuff;
- FILE* pOutFile;
- FilesMsg getFileMsg;
- int ret;
- ret = OpenMasFile( "E://PhotoPak.mase", 1 );
- if ( ret == -1 )
- goto __exit;
- ret = GetFileMessage( "E://查看.exe", &getFileMsg );
- if ( ret == -1 )
- goto __exit;
- pBuff = ( byte* )malloc( getFileMsg.uFileSize );
- ret = ReadFileFromPak( getFileMsg, pBuff );
- if ( ret == -1 )
- goto __exit_free;
- pOutFile = fopen( "E://查看_out.exe", "wb" ); // 注意使用的是二進制模式
- if ( ret == -1 )
- goto __exit_free;
- fwrite( pBuff, getFileMsg.uFileSize, 1, pOutFile );
- fclose( pOutFile );
- __exit_free:
- free( pBuff );
- __exit:
- CloseMasFile();
- return 0;
- }
很清楚了吧，直接先傳入路徑，然後獲得文件的信息，方便我們分配空間。然後我是將從包裏獲取出來的文件又寫到磁盤裏，命名爲查看_out.exe, 同樣既然是獲取了pBuff，你同樣可以在內存中使用這個文件，一舉兩得。然後獲取出來，運行這個獲取的查看_out.exe看是不是能運行。我在WINDOWS XP SP3 下是能運行的，你可以用你自己的一個exe來測試，隨便用什麼文件。
這裏還要說到幾個注意事項：
1. 這裏我只是測試了較小的文件解包和寫包，如果文件比較大的話，可以用分塊進行讀寫。
2. 我沒有寫任何的加密算法和壓縮算法，這裏只是展示了基本原理。也沒有太多的效率和安全考慮。
3. 我這裏使用的都是E盤根目錄下的文件，你也完全可以不是跟目錄，在包文件裏面是沒有文件夾的概念的，如果沒有在根目錄，你可以在解包的時候，根據路徑先創建好文件夾在磁盤上，然後再將包裏讀出來的文件寫到相應的路徑下，這就實現了不同文件夾管理的功能。
上面的代碼中用到了fseek和ftell函數，這裏我不打算講解，他們的用法很簡單。如果你不知道可以自己去查閱。
總結：
從上面的講解中，可見文件操作的重要性，同時也認清了文件的本質和一些創新的想法，我一直覺得，只要你熟悉一樣東西。你要用這樣東西來創造價值，就看你的想象力了。而恰恰我們每個人都充滿了各種想象力，你爲何不把這些想象和設想得以實現？就上面的文件操作來看，後面一個簡單的打包程序，你在熟悉文件操作後，完全不需要查閱任何資料就能將它構造出來。假如你想寫一種自己的音樂格式、圖片格式、執行程序格式等，只要你有一整套的規則，那麼你的設想是絕對能夠實現的。區別只是你的這些格式與經典的格式之間誰更優秀。不過很多時候優秀的並非在所有地方都優秀，所以我們還是得創造自己的東西。
本文由於代碼較前面的文章要長一些，其間可能還有BUG，希望大家發現了能夠提出來，我好改進。萬分感謝！本篇及本模塊到此結束