最近实在是太忙了，这篇整整就推迟了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等文件都是由很多个数据块，通常是结构体的形式直接写入文件的，这样文件头记录了很多偏移，很多大小等就显得非常重要了。

最后，我直接写了一个实例，就是简单的打包，解包程序。可以将多个文件放置到一个包文件里，这个包是二进制包。基本的功能已经实现，只需要添加比如压缩，界面等优化工作了。我初步测试了一下是可以成功打包解包的，也没有太多的条件检查和效率考虑，本文重在解释文件操作的灵活性和重要性。好了，直接上代码吧：

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······15001.#include <stdio.h>  
02.#include <string.h>  
03.#include <stdlib.h>  
04. 
05.typedef unsigned int  uint;  
06.typedef unsigned char byte;             
07. 
08.// 包文件中最大可容纳的文件个数  
09.#define MAX_FILE_COUNT 10  
10. 
11.// 全局包文件指针  
12.FILE*  g_pMasFile = NULL;  
13. 
14.// 资源包文件头结构  
15.typedef struct SMaseFileHeader  
16.{  
17.    uint  uFileFlag;       // 包文件头标记: 'MASE'  
18.    uint  uFileCount;      // 包内文件个数  
19.    uint  uFileListOfs;    // 文件列表偏移  
20.    uint  uMaxFileCount;   // 最大子文件个数  
21.    uint  uFileSize;       // 包文件的大小  
22.}MaseHeader;  
23. 
24.// 包内文件信息结构  
25.typedef struct SFilesMessage  
26.{  
27.    uint  uFileOfs;          // 本文件在包内的偏移  
28.    uint  uFileSize;         // 本文件的大小  
29.    char  szFileName[ 260 ]; // 本文件的路径  
30.}FilesMsg;  
31. 
32. 
33.// 打开包文件  
34.int OpenMasFile( const char* path, const byte onlyOpen )  
35.{  
36.    uint       uWriteCount;       // 写入文件信息次数；  
37.    byte       bIsNew = 0;        // 是否新建的  
38.    MaseHeader header;            // 文件头结构定义  
39.    FilesMsg   msg;  
40. 
41.    g_pMasFile = fopen( path, "rb" );  // 用来判断是否存在  
42.    if ( g_pMasFile == NULL )          // 这里就没有用windows API了  
43.    {  
44.        if ( onlyOpen == 1 )           // 只打开不新建  
45.            return -1;  
46. 
47.        bIsNew = 1;  
48.        g_pMasFile = fopen( path, "wb" );  
49.        if ( g_pMasFile == NULL )  
50.            return -1;  
51.    }  
52. 
53.    // 先关闭，然后在用"rb+"方式打开  
54.    fclose( g_pMasFile );  
55. 
56.    g_pMasFile = fopen( path, "rb+" );  
57.    if ( g_pMasFile == NULL )  
58.        return -1;  
59. 
60.    if ( bIsNew == 1 ) // 新建的文件  
61.    {  
62.        header.uFileFlag     = 'ESAM';  
63.        header.uFileCount    = 0;  
64.        header.uFileListOfs  = sizeof( MaseHeader ); // 紧跟着就是文件列表  
65.        header.uMaxFileCount = MAX_FILE_COUNT;  
66.        header.uFileSize     = sizeof( MaseHeader )   
67.                               + ( MAX_FILE_COUNT * sizeof( FilesMsg ) );  
68. 
69.        // 写入头信息  
70.        fwrite( &header, sizeof( MaseHeader ), 1, g_pMasFile );  
71. 
72.        memset( &msg, 0, sizeof( FilesMsg ) );  
73.        uWriteCount = MAX_FILE_COUNT;  
74. 
75.        // 写入文件列表用0占位  
76.        while( uWriteCount-- )  
77.            fwrite( &msg, sizeof( FilesMsg ), 1, g_pMasFile );  
78.    }  
79.    else  // 文件存在  
80.    {  
81.        // 则读取头文件信息  
82.        fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );  
83.    }  
84. 
85.    // 检查文件头标记  
86.    if ( header.uFileFlag != 'ESAM' )  
87.    {  
88.        fclose( g_pMasFile );  
89.        return -1;  
90.    }  
91. 
92.    // 检查数据是否完整  
93.    if ( header.uMaxFileCount != MAX_FILE_COUNT )  
94.    {  
95.        fclose( g_pMasFile );  
96.        return -1;  
97.    }  
98. 
99.    return 0;  
100.}  
101. 
102.// 写文件到包里  
103.int WriteFileToPak( const char* path )  
104.{  
105.    FilesMsg   fileMsg;      // 此文件的文件信息结构  
106.    MaseHeader header;       // 包文件头结构定义  
107.    uint       uFileSize;  
108.    uint       uFileListEndOfs;  
109.    byte*      pBuff;  
110.    FILE*      pFile = NULL;  
111. 
112.    if ( g_pMasFile == NULL )  
113.        return -1;  
114. 
115.    memset( &fileMsg, 0, sizeof( FilesMsg ) );  
116.    fseek( g_pMasFile, 0, SEEK_SET );  
117. 
118.    // 则读取头文件信息  
119.    fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );  
120. 
121.    uFileListEndOfs = header.uFileCount * sizeof( FilesMsg ) + header.uFileListOfs;  
122. 
123.    pFile = fopen( path, "rb" );  
124.    if ( pFile == NULL )  
125.        return -1;  
126. 
127.    fseek( pFile, 0, SEEK_END );  
128.    uFileSize = ftell( pFile );  
129.    fseek( pFile, 0, SEEK_SET );  
130. 
131.    // 文件名长度不能超过260  
132.    strcpy( fileMsg.szFileName, path );  
133.    fileMsg.uFileOfs  = header.uFileSize;  
134.    fileMsg.uFileSize = uFileSize;  
135. 
136.    // 写入文件信息  
137.    // 将文件指针定位到uFileListEndOfs处，以便写入新的文件信息结构  
138.    fseek( g_pMasFile, uFileListEndOfs, SEEK_SET );  
139.    fwrite( &fileMsg, sizeof( FilesMsg ), 1, g_pMasFile );  
140. 
141.    // 申请空间  
142.    pBuff = ( byte* )malloc( uFileSize );  
143.    fread( pBuff, uFileSize, 1, pFile );  
144. 
145.    // 写数据到包文件里  
146.    fseek( g_pMasFile, header.uFileSize, SEEK_SET );  
147.    fwrite( pBuff, uFileSize, 1, g_pMasFile );  
148. 
149.    // 释放内存  
150.    free( pBuff );  
151. 
152.    // 重新填充header  
153.    header.uFileCount += 1;  
154.    header.uFileSize  += uFileSize;  
155. 
156.    fseek( g_pMasFile, 0, SEEK_SET );  
157. 
158.    // 重新写入包文件头  
159.    fwrite( &header, sizeof( MaseHeader ), 1, g_pMasFile );  
160. 
161.    return 0;  
162.}  
163. 
164.// 从包文件里读数据  
165.int ReadFileFromPak( const FilesMsg msg, byte* _dst )  
166.{  
167.    if ( g_pMasFile == NULL )  
168.        return -1;  
169. 
170.    fseek( g_pMasFile, msg.uFileOfs, SEEK_SET );  
171.    fread( _dst, msg.uFileSize, 1, g_pMasFile );  
172. 
173.    return 0;  
174.}  
175. 
176.// 获取包中某个文件的信息  
177.int GetFileMessage( const char* path, FilesMsg* msg )  
178.{  
179.    FilesMsg   fileMsg;      // 此文件的文件信息结构  
180.    MaseHeader header;       // 包头结构  
181.    uint       uFileCount;   // 文件个数  
182. 
183.    if ( g_pMasFile == NULL || msg == NULL )  
184.        return -1;  
185. 
186.    // 则读取头文件信息  
187.    fseek( g_pMasFile, 0, SEEK_SET );  
188.    fread( &header, sizeof( MaseHeader ), 1, g_pMasFile );  
189. 
190.    uFileCount = header.uFileCount;  
191.    while ( uFileCount-- )  
192.    {  
193.        fread( &fileMsg, sizeof( FilesMsg ), 1, g_pMasFile );  
194. 
195.        // 判断是否是要获取的文件  
196.        if ( stricmp( fileMsg.szFileName, path ) == 0 )  
197.        {  
198.            *msg = fileMsg;  
199.            return 0;  
200.        }  
201.    }  
202. 
203.    return -1;  
204.}  
205. 
206.// 关闭包文件  
207.int CloseMasFile( void )  
208.{  
209.    if ( g_pMasFile == NULL )  
210.        return -1;  
211. 
212.    fclose( g_pMasFile );  
213.    g_pMasFile = NULL;  
214. 
215.    return 0;  
216.} 
#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·······15001.int main( void )  
02.{  
03.    int ret;  
04. 
05.    ret = OpenMasFile( "E://PhotoPak.mase", 0 );  
06.    if ( ret == -1 )  
07.        goto __exit;  
08. 
09.    WriteFileToPak( "E://大山.jpg" );  
10.    WriteFileToPak( "E://海水.bmp" );  
11.    WriteFileToPak( "E://查看.exe" );  
12.    WriteFileToPak( "E://加载.dll" );  
13.    WriteFileToPak( "E://说明.txt" );  
14. 
15.__exit:  
16.    CloseMasFile();  
17.    return 0;  
18.}  
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·······15001.int main( void )  
02.{  
03.    byte*       pBuff;  
04.    FILE*       pOutFile;  
05.    FilesMsg    getFileMsg;  
06.    int         ret;  
07. 
08.    ret = OpenMasFile( "E://PhotoPak.mase", 1 );  
09.    if ( ret == -1 )  
10.        goto __exit;  
11.      
12.    ret = GetFileMessage( "E://查看.exe", &getFileMsg );  
13.    if ( ret == -1 )  
14.        goto __exit;  
15. 
16.    pBuff = ( byte* )malloc( getFileMsg.uFileSize );  
17.    ret = ReadFileFromPak( getFileMsg, pBuff );  
18.    if ( ret == -1 )  
19.        goto __exit_free;  
20. 
21.    pOutFile = fopen( "E://查看_out.exe", "wb" );  // 注意使用的是二进制模式  
22.    if ( ret == -1 )  
23.        goto __exit_free;  
24. 
25.    fwrite( pBuff, getFileMsg.uFileSize, 1, pOutFile );  
26.    fclose( pOutFile );  
27.      
28.__exit_free:  
29.    free( pBuff );  
30. 
31.__exit:  
32.    CloseMasFile();  
33.    return 0;  
34.}  
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函数，这里我不打算讲解，他们的用法很简单。如果你不知道可以自己去查阅。

总结：

从上面的讲解中，可见文件操作的重要性，同时也认清了文件的本质和一些创新的想法，我一直觉得，只要你熟悉一样东西。你要用这样东西来创造价值，就看你的想象力了。而恰恰我们每个人都充满了各种想象力，你为何不把这些想象和设想得以实现？就上面的文件操作来看，后面一个简单的打包程序，你在熟悉文件操作后，完全不需要查阅任何资料就能将它构造出来。假如你想写一种自己的音乐格式、图片格式、执行程序格式等，只要你有一整套的规则，那么你的设想是绝对能够实现的。区别只是你的这些格式与经典的格式之间谁更优秀。不过很多时候优秀的并非在所有地方都优秀，所以我们还是得创造自己的东西。

本文由于代码较前面的文章要长一些

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/masefee/archive/2010/03/03/5341738.aspx