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( 13₁₀ )）等）。那樣插入進去后，然后在解包時再采用非二進制方式寫入文件就不是原來的文件了，這點大家要注意。

 

好了，寫了這么幾個文件后，再看看怎么把他們從包里面弄出來，然后能夠正常的打開和查看：

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盤根目錄下的文件，你也完全可以不是跟目錄，在包文件里面是沒有文件夾的概念的，如果沒有在根目錄，你可以在解包的時候，根據路徑先創建好文件夾在磁盤上，然后再將包里讀出來的文件寫到相應的路徑下，這就實現了不同文件夾管理的功能。