c文件操做

時間 2019-11-12

標籤文件欄目 C&C++ 简体版

原文原文鏈接

所謂文件（file）通常指存儲在外部介質上數據的集合，好比咱們常用的mp三、mp四、txt、bmp、jpg、exe、rmvb等等。這些文件各有各的用途，咱們一般將它們存放在磁盤或者可移動盤等介質中。那麼，爲何這裏面又有這麼多種格式的文件呢？緣由很簡單，它們各有各的用途，區分就在於這些文件裏面存放的數據集合所遵循的存儲規則不同。舉個例子好比bmp圖片文件，爲何他可以表示一張圖片，由於它有固定的格式，哪一段到哪一段，哪一個偏移到哪一個偏移應該存放什麼數據是規定好了的。好比有文件頭，通常是一個結構體，存放的文件的一些信息，如圖片的大小，像素等等。再後來有數據區。而後咱們要顯示一張圖片，就只須要按照前面所說的規則將文件頭結構和數據塊讀出來，而後將這些數據在屏幕上用顏色表示出來，就成了一張圖片。其它文件格式也相似。html

這裏要說一個更重要的例子，對咱們理解文件有好處。那麼這個文件就是exe文件（這裏只討論windows平臺），一般咱們認爲它是一個可執行程序，這無疑是增長了它的神祕度。從本質上來說exe無非是一種固定的文件格式罷了。既然這樣，它就有一套本身的存儲規則。跟前面的圖片文件同樣有規則。此時，你可能會問：你這麼說那我就能夠純手工（直接填寫數據填充文件）寫出一個exe可執行文件了？面對你這個問題，我只能說你已經習慣思考了，已經習慣給本身提問了，已經很聰明瞭。那麼答案是確定的，你徹底能夠用一個編輯器直接填寫數據寫出一個helloworld.exe文件或者helloworld.dll文件。由於這些具備必定格式規則的文件通常是二進制存儲的，因而咱們能夠用一個二進制編輯器新建一個二進制文件，而後向裏面填寫數據。而後雙擊運行輸出「helloworld」字符串。你可能會以爲頗有成就感，我以前就寫過一個exe和dll。這裏exe和dll的文件格式也就是著名的PE文件格式。有興趣你能夠去查閱相關資料，此非本文重點。程序員

總結上面的認識，文件無非就是一段數據的集合，這些數據能夠是有規則的集合，也能夠是無序的集合。操做系統也就是以文件爲單位對數據進行管理的。也就是說，要訪問外部介質上的數據，必須先按照文件名進行查找，而後從該文件中讀取數據。要想寫數據到外部介質，必須得創建一個文件，而後再寫入。所以，這樣來看，你眼前的文件將是一堆一堆數據而已，也沒有什麼類型文件之分了，類型只是爲了區分而已，假如你把一個exe文件的擴展名改成txt，把它用記事本打開，一樣是可行的，只是會執行exe文件裏面的東西而已。（這裏又不得不提到一點，若是你是一名程序員或者愛好者，那麼你不該該將你的文件擴展名給隱藏了，要讓它顯示出來，若是你隱藏了，無非是增長了它的神祕感，同時在文件操做上不方便。經過上面的本質，我相信你能體會到我爲何這麼說。）算法

說到這裏，你應該知道文件是什麼了，那麼再來看二進制文件和ASCII文本文件，爲何要分爲這兩種呢？windows

首先、文本文件方式存儲多用於咱們須要明顯知道文件裏面的內容時，好比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+"等。

上面的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+"(讀寫)	爲讀寫打開一個二進制文件，不存在則建立，存在則追加

1、讀寫字符

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 );

當執行完此函數後，數據便寫進了文件，最後再關閉文件。

2、讀寫字符串

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結束寫入文件，這是跟一般狀況同樣的，能夠不用關心。

3、格式化數據讀寫

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"兩種方式，其它方式你能夠自行測試，也沒有什麼特別的。若是你是用上面的函數去讀取二進制序列，也是沒有錯的，只不過你更很差控制而已。至於和"+"組合也沒有什麼特別的，無非就是在文件尾部追加，原理同樣，你們能夠自行測試。

4、文件數據塊讀寫

一樣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來測試，隨便用什麼文件。