上面结构体中的_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函数，这里我不打算讲解，他们的用法很简单。如果你不知道可以自己去查阅。
总结：
从上面的讲解中，可见文件操作的重要性，同时也认清了文件的本质和一些创新的想法，我一直觉得，只要你熟悉一样东西。你要用这样东西来创造价值，就看你的想象力了。而恰恰我们每个人都充满了各种想象力，你为何不把这些想象和设想得以实现？就上面的文件操作来看，后面一个简单的打包程序，你在熟悉文件操作后，完全不需要查阅任何资料就能将它构造出来。假如你想写一种自己的音乐格式、图片格式、执行程序格式等，只要你有一整套的规则，那么你的设想是绝对能够实现的。区别只是你的这些格式与经典的格式之间谁更优秀。不过很多时候优秀的并非在所有地方都优秀，所以我们还是得创造自己的东西。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/masefee/archive/2010/03/03/5341738.aspx