内存中模拟目录和文件，软件资源保护新办法
项目中常常需要将中间结果进行保存, 以供后续步骤进行处理. 如果以临时文件的方式往往容易"暴露"中间机密信息. 同时，文件IO读写也较浪费时间（说到这里，不得不BS一下windows的文件系统，当一个目录下的文件数目超过10000时，读写文件相当慢，Linux却没有这样的问题）．
面对上面情况，本人想到了内存机制：
如果中间结果数据不超过2G(32位windows的内存地址上限)．可以在内存中模拟一个文件系统．将这些信息以"内存文件"形式保存在"内存"，同时也能提供"内存目录"（或"内存Db"）支持．
下面是"内存文件类"的使用示例(使用上和一般的文件类没任何区别，只是不在磁盘上生成文件):
CMemoryFile pfile;
pfile.fopen( "c:/www/1235.bxk", "wb" );
pfile.fprintf( "aaa\nbbb\n" );
pfile.fclose();
CMemoryFile pfile0;
pfile0.fopen( "c:/www/1234.bxk", "wb" );
pfile0.fprintf( "aaa\nbbb\n" );
pfile0.fclose();
// 删除文件"1234.bxk"
bool bRs = RemoveMemDbfile( "c:/www/1234.bxk" );
RemoveMemDbfile( "c:/www/1235.bxk" );
ASSERT( bRs );
// 遍历内存目录"c:/www"下的所有文件（输出文件名）．
CBlockIter blkIter( "c:/www" );
while ( blkIter.next() )
{
char szfn[256];
blkIter.getBlockFn( szfn );
printf( "file:%s", szfn );
}
// 按行读取"1235.bxk"下的内容.
CMemoryFile pfile1;
pfile1.fopen( "c:/www/1235.bxk", "rb" );
char szline[256];
while ( pfile1.fgets(szline, sizeof(szline)))
{
printf("%s", szline);
}
pfile1.fclose();
使用上是不是相当easy? 其实实现起来也不复杂，出于下面目的所以拿出来共享：一方便如果能为您节省一点点开发时间，本人将非常高兴；另一方面，提高水平的方式是"晒代码"，有啥批抨的尽量提，洗耳恭听！
具何实现:
// MemoryFile.h: interface for the CMemoryFile class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_MEMORYFILE_H__0A6B4842_05D3_4B2A_A1EC_BAF340135266__INCLUDED_)
#define AFX_MEMORYFILE_H__0A6B4842_05D3_4B2A_A1EC_BAF340135266__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <stdarg.h>
#include <map>
#include <string>
#include <vector>
#include <assert.h>
#define ASSERT assert
//#define pprintf printf
#define pprintf
const char* safe_strtok(const char* sz,
const char* szToken, std::string& str);
class CMemoryDb;
class CGlobalMan
{
public:
std::map<std::string, CMemoryDb*> mapName2MemDb;
CGlobalMan()
{
}
virtual ~CGlobalMan();
};
extern CGlobalMan* g_pGlobal;
// [内存"磁盘"]:模拟一个目录
// 对外接口：
// 1.根据文件名，往[内存"磁盘"]读写文件.
// 2.可以删除[内存"磁盘"]内的某个文件。
// 3.可遍历[内存"磁盘"]内的所有文件名（同时获取文件属性m_nSegCnt和m_nNodCnt）。
// 4.根据目录名，可创建或查找[内存"磁盘"]。
typedef struct tagFINFO
{
char szfn[64];
int nlen;
int scnt;
int ncnt;
void* pdata;
tagFINFO()
{
memset( szfn, 0, sizeof(szfn) );
nlen = 0;
scnt = 0;
ncnt = 0;
pdata= NULL;
}
}FINFO;
class CMemoryDb
{
std::map<std::string, FINFO> mapFn2Content;
std::map<std::string, FINFO>::iterator m_it;
public:
CMemoryDb()
{
pprintf("CMemoryDb()");
}
virtual ~CMemoryDb();
// 读写文件
void* FindFile( const char fn[], int* nLen )
{
if (nLen) *nLen = 0;
if ( mapFn2Content.find(fn) == mapFn2Content.end() )
return NULL;
FINFO& pinfo = mapFn2Content[fn];
if (nLen) *nLen = pinfo.nlen;
return &pinfo;
}
void* CreateFile( const char fn[], const int nLen )
{
// nLen为零:外部分配内存(目前只支持这种), pRet->pdata == NULL
ASSERT( nLen == 0 );
FINFO item;
strcpy( item.szfn, fn );
mapFn2Content[fn] = item;
return &(mapFn2Content[fn]);
}
// 删除文件
bool DeleteFile( const char fn[] )
{
if ( mapFn2Content.find(fn) != mapFn2Content.end() )
{
delete mapFn2Content[fn].pdata;
mapFn2Content.erase( fn );
return true;
}
return false;
}
// 遍历
bool Begin_DbItem()
{
m_it = mapFn2Content.begin();
return true;
}
bool Next_DbItem()
{
bool bret = ( m_it != mapFn2Content.end() );
if ( bret ) m_it ++;
return bret;
}
void* Get_DbItem()
{
if ( m_it == mapFn2Content.end() )
return NULL;
return &(m_it->second);
}
public:
// 查找或创建[内存"磁盘"]
static CMemoryDb* MemDbLookup( const char* dbname )
{
if ( g_pGlobal->mapName2MemDb.find( dbname ) ==
g_pGlobal->mapName2MemDb.end())
return NULL;
return (CMemoryDb*)g_pGlobal->mapName2MemDb[dbname];
}
static CMemoryDb* CreateMemDb( const char* dbname )
{
CMemoryDb* pDb = MemDbLookup(dbname);
if(pDb) return pDb;
pDb = new CMemoryDb;
ASSERT( g_pGlobal->mapName2MemDb.find( dbname ) ==
g_pGlobal->mapName2MemDb.end() );
g_pGlobal->mapName2MemDb[dbname] = pDb;
return pDb;
}
private:
};
// MemDb文件枚举类
class CBlockIter
{
private:
CMemoryDb *m_pMDb;
bool m_bReady;
std::vector<FINFO> m_vctBlks;
int m_index;
public:
CBlockIter( const char* db_name ):m_pMDb(NULL),
m_bReady(true), m_index(-1)
{
m_pMDb = CMemoryDb::MemDbLookup( db_name );
if ( !m_pMDb )
{
ASSERT(0);
m_bReady = false;
return;
}
m_vctBlks.clear();
FINFO* pfinf = NULL;
m_pMDb->Begin_DbItem();
while ( pfinf = (FINFO*)m_pMDb->Get_DbItem() )
{
m_vctBlks.push_back( *pfinf );
m_pMDb->Next_DbItem();
}
finalize();
}
virtual ~CBlockIter()
{
finalize();
}
bool next()
{
if ( !m_bReady ) return false;
m_index ++;
if ( m_index == (int)m_vctBlks.size() ) return false;
return true;
}
int getBlockFn( char fn[] )
{
strcpy( fn, m_vctBlks[m_index].szfn );
return 0;
}
int getBlockId()
{
char* pszNum = m_vctBlks[m_index].szfn;
int r = 0;
if( pszNum )
sscanf( pszNum, "%x", &r );
return r;
}
int getSegCnt()
{
return m_vctBlks[m_index].scnt;
}
int getNodeCnt()
{
return m_vctBlks[m_index].ncnt;
}
private:
void finalize()
{
if ( m_pMDb ) m_pMDb = NULL;
}
};
// [内存"磁盘"]文件 读写类
// 对外接口：
// 1.根据文件名，创建或打开内存文件。
// 2.fgets或fprintf字符串读写,可写入文件属性m_nSegCnt和m_nNodCnt。
typedef unsigned char BYTE;
class CMemoryFile
{
CMemoryDb* m_pMDb;
int m_nSegCnt;
int m_nNodCnt;
int m_nIsRead;
int m_nReadLen;
int m_nOffset;
FINFO* m_pSream;
char m_dbName[256];
std::string m_strData;
public:
CMemoryFile():m_pMDb(NULL), m_nSegCnt(0),
m_nNodCnt(0), m_nIsRead(0), m_nReadLen(0), m_nOffset(0), m_pSream(NULL)
{
}
virtual ~CMemoryFile()
{
close();
}
// added by wuwenwen
bool fopen( const char* fname, const char* mode )
{
// 获取目录名，文件名
char szDirName[256];
strcpy( szDirName, fname );
const char* h = szDirName;
std::string strFName;
h = safe_strtok(h, "/\\", strFName);
while (h)
{
h = safe_strtok(h, "/\\", strFName);
}
szDirName[ strlen(szDirName) - strFName.length() - 1 ] = ’\0’;
close();
strcpy( m_dbName, szDirName );
m_pMDb = CMemoryDb::CreateMemDb( m_dbName );
if ( !m_pMDb )
{
return false;
}
if ( strcmp( mode, "wb" ) == 0 )
{
m_nIsRead = 0;
}
else if ( strcmp( mode, "rb" ) == 0 )
{
m_nIsRead = 1;
}
else
{
ASSERT(0);
return false;
}
if ( !m_nIsRead )
{
pprintf("write\n");
// 存在就先删掉
m_pSream = (FINFO*)m_pMDb->FindFile(strFName.c_str(), NULL);
if ( m_pSream )
{
pprintf( "delete file:%s\n", strFName.c_str( ) );
m_pMDb->DeleteFile(strFName.c_str());
}
m_pSream = (FINFO*)m_pMDb->CreateFile(strFName.c_str(), 0);
m_strData.reserve( 6 * 1024 * 1024 );
}
else
{
pprintf("read\n");
// 文件存在?
m_pSream = (FINFO*)m_pMDb->FindFile(strFName.c_str(), &m_nReadLen);
if ( !m_pSream )
{
::fprintf( stdout, "read:%s,not existed\n", strFName.c_str() );
return false;
}
}
return true;
}
int fgets( char* line, int nsize )
{
if ( !m_nIsRead ) return 0;
if( m_nOffset == m_nReadLen ) return 0;
char* pl = line;
char* pb = &(((char *)m_pSream->pdata)[ m_nOffset ]);
while( *pb == ’\n’ )
{
pb ++;
m_nOffset ++;
}
if( m_nOffset == m_nReadLen ) return 0;
for( ; m_nOffset < m_nReadLen &&
nsize && *pb != ’\n’; pb++, nsize -- )
{
*pl++ = *pb;
m_nOffset++;
}
if ( (pl - line) && *pb == ’\n’ )
{
*pl++ = ’\n’;
*pl = ’\0’;
}
else
{
*pl = ’\0’;
}
return (int)(pl - line);
}
int fprintf( const char* szFormat, ... )
{
if ( m_nIsRead ) return 0;
int done = 0;
char s[65000];
va_list arg;
va_start (arg, szFormat);
done = vsprintf (s, szFormat, arg);
va_end (arg);
pprintf( "fprintf %s\n", s );
m_strData += s;
return done;
}
bool fclose()
{
close();
return true;
}
bool setcnt( int segcnt, int nodcnt )
{
m_nSegCnt = segcnt;
m_nNodCnt = nodcnt;
return true;
}
private:
bool close()
{
if ( !m_nIsRead ) flush();
if(m_pMDb || m_pSream)
{
m_pMDb = NULL;
m_pSream = NULL;
}
return true;
}
bool flush()
{
if ( !m_pSream || m_nIsRead ||
m_strData.length() == 0 ) return false;
int nlen = m_strData.length();
BYTE* pdata = new BYTE[nlen];
memcpy( pdata, m_strData.c_str(), nlen );
// 内部没分配内存
ASSERT( m_pSream->pdata == NULL );
m_pSream->nlen = nlen;
m_pSream->scnt = m_nSegCnt;
m_pSream->ncnt = m_nNodCnt;
m_pSream->pdata = pdata;
m_strData.erase();
}
};
bool RemoveMemDbfile( const char szfn[] );
#endif // !defined(AFX_MEMORYFILE_H__0A6B4842_05D3_4B2A_A1EC_BAF340135266__INCLUDED_)
// MemoryFile.cpp: implementation of the CMemoryFile class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "MemoryFile.h"
// 这里还要定义
CGlobalMan g_Global;
CGlobalMan* g_pGlobal = &g_Global;
CMemoryDb::~CMemoryDb()
{
std::map<std::string, FINFO>::iterator it;
for ( it = mapFn2Content.begin();
it != mapFn2Content.end(); it ++ )
{
delete it->second.pdata;
}
pprintf("~CMemoryDb()\n");
}
CGlobalMan::~CGlobalMan()
{
// 全局析构
std::map<std::string, CMemoryDb*>::iterator it;
for ( it = mapName2MemDb.begin();
it != mapName2MemDb.end(); it ++ )
{
CMemoryDb* pmd = (CMemoryDb*)it->second;
delete pmd;
}
pprintf("~CGlobalMan()\n");
}
bool RemoveMemDbfile( const char szfn[] )
{
// 获取目录名，文件名
char szDirName[256];
strcpy( szDirName, szfn );
const char* h = szDirName;
std::string strFName;
h = safe_strtok(h, "/\\", strFName);
while (h)
{
h = safe_strtok(h, "/\\", strFName);
}
szDirName[ strlen(szDirName) - strFName.length() - 1 ] = ’\0’;
CMemoryDb* pmd = CMemoryDb::MemDbLookup( szDirName );
if ( !pmd ) return false;
return pmd->DeleteFile( strFName.c_str() );
}
const char* safe_strtok(const char* sz, const char* szToken, std::string& str)
{
int i = 0;
for( i=0; sz[i] != ’\0’; i++ )
{
if ( strchr( szToken, sz[i] ) != NULL )
{
break;
}
}
str = std::string( sz, i );
return ( sz[i] == ’\0’ ) ? NULL : &sz[i+1];
}
