上面結構體中的_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

    10000                 "masefee"             燙燙

因為我們在為name拷貝字符串時，并沒有將name的所有字符清零，因此系統默認初識化為0xcc，為什么初始化為0xcc，之前我應該提過，主要是這個0xcc是匯編中斷指令的機器碼，主要防止訪問越解釋，進行中斷報錯。而0xcc就是中文編碼的“燙”字。

最后面的兩個“燙”還不能省略，因為我們是以塊寫入文件的，如果去掉兩個cc，那么將沒有16字節，如果有多個結構體變量的數據一塊兒寫到文件中時，結構體的數據對齊是非常重要的，否則將讀寫越界，跟內存一樣。這里就好比內存的一個映射。

至于為什么會出現亂碼，是因為超過可現實ASCII碼值，看上去就是亂的，其實數據還是正常的。

理解了fwrite函數后，fread函數就簡單了，由于篇幅原因我這里只寫關鍵：

Student stu_out;

fread( &stu_out, sizeof( Student ), 1, pReadFile );

這樣就能填充好stu_out結構體變量，我想你已經體會到了數據塊讀寫時，數據對齊的重要性了。在游戲的資源包，就是采用的數據塊的存儲形式，同時bmp、jpg、exe、dll等文件都是由很多個數據塊，通常是結構體的形式直接寫入文件的，這樣文件頭記錄了很多偏移，很多大小等就顯得非常重要了。

最后，我直接寫了一個實例，就是簡單的打包，解包程序。可以將多個文件放置到一個包文件里，這個包是二進制包。基本的功能已經實現，只需要添加比如壓縮，界面等優化工作了。我初步測試了一下是可以成功打包解包的，也沒有太多的條件檢查和效率考慮，本文重在解釋文件操作的靈活性和重要性。好了，直接上代碼吧：

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#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;  
} 
#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, 這個隨意哈，文件頭結構上面已經很清晰了。由于篇幅的原因，這里就不一一解說了，我貼了很多注釋。應該能夠看懂的。

有了上面的接口，我們就可以來操作這個包文件了，先是看怎么寫入：

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
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;  
}  
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 )）等）。那樣插入進去后，然后在解包時再采用非二進制方式寫入文件就不是原來的文件了，這點大家要注意。

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

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
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;  
}  
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函數，這里我不打算講解，他們的用法很簡單。如果你不知道可以自己去查閱。

總結：

從上面的講解中，可見文件操作的重要性，同時也認清了文件的本質和一些創新的想法，我一直覺得，只要你熟悉一樣東西。你要用這樣東西來創造價值，就看你的想象力了。而恰恰我們每個人都充滿了各種想象力，你為何不把這些想象和設想得以實現？就上面的文件操作來看，后面一個簡單的打包程序，你在熟悉文件操作后，完全不需要查閱任何資料就能將它構造出來。假如你想寫一種自己的音樂格式、圖片格式、執行程序格式等，只要你有一整套的規則，那么你的設想是絕對能夠實現的。區別只是你的這些格式與經典的格式之間誰更優秀。不過很多時候優秀的并非在所有地方都優秀，所以我們還是得創造自己的東西。