小样：内存管理系统实现，提供可持久化功能

基本思想：
1.把内存分块管理，这里是把内存分为64字节一块
2.下一块的地址，不是存储下一块的地址，而是相对偏移地址，为了持久化，
3.把首64字节为保留空间，分别记录 空闲块链表的首地址，使用块链表的首地址

首64字节定义

struct HeadInfo
{
int freeList;
int usedList;
unsigned int count;
int unused[]
};

块的定义如下

class DString
{
public:
int size;
//the next node offset
int next;
char valueStr[valueSize];
DString()
{
size=0;
next=-1;
memset(valueStr,0,valueSize*sizeof(char));
}
DString(char *str,int length)
{
size=0;
next=-1;
memset(valueStr,0,sizeof(char)*valueSize);
assert(length<=valueSize);
memcpy(valueStr,str,length);
size=length;
}
void setSize(int size)
{
this->size=size;
}
void setNextLocation(int location)
{
next=location;
}
~DString()
{
size=0;
next=0;
memset(valueStr,0,valueSize*sizeof(char));
}
};

记得块的初始化，其中 next 执行该块的下一块相对偏移量，通过基地址+next可以找到下一块。

内存管理的集体实现

#include<iostream>
#include<fstream>
#include "StringPool.h"
#include"dString.h"
#include"HeadInfo.h"
using namespace std;
CStringPool::CStringPool ():poolSize(0x1000)
{
cout<<"CStringPool"<<endl;
assert(sizeof(HeadInfo)<=sizeof(DString));
poolP=NULL;
poolP=(char *)malloc(sizeof(char)*poolSize);
assert(poolP!=NULL);
DString fillInfo;
int DSsize=sizeof(DString);
int offset=0;
int nodeCount=poolSize/sizeof(DString);
for(int i=0;i<nodeCount;i++)
{
if(i!=nodeCount-1)
{
fillInfo.setNextLocation(offset+DSsize);
}
else
{
fillInfo.setNextLocation(-1);
}
memcpy(poolP+offset,&fillInfo,DSsize);
offset+=DSsize;
}

head=(HeadInfo*)poolP;
head->freeList=0+DSsize;
head->count=0;
head->usedList=-1;
#ifdef BUG
printList(head->freeList);
#endif
}

void CStringPool::printList(int index)
{
DString * tem1,*tem2;
int prelocation,nowLocation;
tem1=getNodeList(index);
if(tem1!=NULL)
cout<<"locaiton : "<<index<<endl;
prelocation=index;
while((tem2=getNextNode(tem1))!=NULL)
{
nowLocation=tem1->next;
cout<<"prelocaiton: "<<prelocation<<", now location"<<nowLocation<<" "<<nowLocation-prelocation<<endl;
prelocation=nowLocation;
tem1=tem2;
}
}

DString* CStringPool::getNodeList(int offset)
{
DString *beginLocation;
beginLocation=(DString*) ( poolP+offset);
return beginLocation;
}
int CStringPool ::getNodeIndex(DString *node)
{
int index= (char *)node -(char*)poolP;
if((unsigned int)index>(poolSize-sizeof(DString)))
{
return -1;
}
return index;
}

DString *  CStringPool::getNextNode( DString *nowNode)
{
DString * temP=NULL;
if(nowNode->next>0)
{
temP=(DString*) (poolP+nowNode->next);
}
return temP;
}

DString* CStringPool::getFreeNodesAndRemoveFromeFreelist(int nodeNum)
{
if((head->count+nodeNum)*sizeof(DString)>poolSize)
{
return NULL;
}
DString *beginLocation;
DString * endLocation=NULL;
beginLocation=(DString*)(poolP+head->freeList);
endLocation=beginLocation;
for(int i=1;i<nodeNum;i++)
{
endLocation=getNextNode(endLocation);
assert(endLocation!=NULL);
}
head->freeList=endLocation->next;
endLocation->next=-1;
return beginLocation;
}
DString* CStringPool::getPreNodeInUseList(int index)
{
int usedbegin=head->usedList;
//if index pointer to the head node
if(usedbegin==index)
{
return getNodeList(index);
}
if(usedbegin<0)
{
return NULL;
}
DString *usedList=getNodeList(usedbegin);
while(usedList!=NULL)
{
if(usedList->next==index)
{
return usedList;
}
usedList=getNextNode(usedList);
}
return NULL;
}

/*
return 0 oK
return -1 the index is out of range;
*/
int CStringPool::getUsedNodesAndRemoveFromeUsedlist(int index)
{
DString *preNode=getPreNodeInUseList(index);
if(preNode!=NULL)
{
int * preIndexP;
if(index==head->usedList)
{
preIndexP=&(head->usedList);
}
else
{
preIndexP=&(preNode->next);
}
DString *delNode=getNodeList(index);
int delLength=delNode->size;
assert(delLength>0);
DString *tem=delNode;
int inNodeOff=sizeof(delNode->next)+sizeof(delNode->size);
//clear the node;
while(delLength>0)
{
if((unsigned int)delLength>(sizeof(DString)-inNodeOff))
{
tem->size=-1;
memset(tem->valueStr,0,sizeof(DString)-inNodeOff);
tem=getNextNode(tem);
}
else
{
tem->size=-1;
memset(tem->valueStr,0,sizeof(DString)-inNodeOff);
break;
}
delLength=delLength-sizeof(DString)+inNodeOff;
}
// link the used list
*preIndexP=tem->next;
tem->next=-1;
//link to the free list
int freeListBeginOffset=head->freeList;
head->freeList=getNodeIndex(delNode);
tem->next=freeListBeginOffset;
return 0;
}
else
{
return -1;
}

}
CStringPool::~CStringPool(void)
{
free(poolP);
}

int CStringPool::set(const string &strIn)
{
DString * nodeList;
int index=-1;
//一个节点中，非用了存储数据的长度
int InnodeOff=sizeof(nodeList->size)+sizeof(nodeList->next);
//将要存储的数据需要占几个节点
int nodeNum=(strIn.size()+sizeof(DString)-1)/(sizeof(DString)-InnodeOff);
const char *cStrP=strIn.c_str();
int length=strIn.size();
nodeList=getFreeNodesAndRemoveFromeFreelist(nodeNum);
if(nodeList==NULL)
{
return -2;
}
index=(char *)nodeList-(char *)poolP;
nodeList->size=strIn.size();
//DString* beginLocation;
//DString *tem;
int leftSize= length;
while(leftSize>0)
{
leftSize=leftSize-sizeof(DString)+InnodeOff;
if(leftSize>=0)
{
memcpy(nodeList->valueStr,cStrP,sizeof(DString)-InnodeOff);
cStrP=cStrP+(sizeof(DString)-InnodeOff);
nodeList=getNextNode(nodeList);
}
else
{
memcpy(nodeList->valueStr,cStrP,leftSize+sizeof(DString)-InnodeOff);
nodeList->next=-1;
}
}
// update the used list;
int oldUsedBeginOffset=head->usedList;
head->usedList=index;
nodeList->next=oldUsedBeginOffset;

return index;
}

bool CStringPool::get(int index, string & strOut)
{
//strOut.clear();
DString *strP=getNodeList(index);
if(strP==NULL)
{
cout<<"wrong index"<<endl;
return false;
}
int strLength=strP->size;
int inNodeOff=sizeof(strP->next)+sizeof(strP->size);
#ifdef BUG
cout<<"the length of the string you will get  is "<<strP->size<<endl;
#endif
while(strLength>0)
{
if((unsigned int)strLength>(sizeof(DString)-inNodeOff))
{
strOut.append(strP->valueStr,(sizeof(DString)-inNodeOff));
strP=getNextNode(strP);
}
else
{
strOut.append(strP->valueStr,strLength);
}
strLength=strLength-(sizeof(DString)-inNodeOff);
}
//cout<<strOut<<endl;
return true;
}

bool CStringPool:: del(int index)
{
int state=getUsedNodesAndRemoveFromeUsedlist(index);
if(state==0)
return true;
else
return false;
}

bool CStringPool::saveToFile(const string &filePath)
{
fstream outPut;
outPut.open(filePath.c_str(),ios::binary|ios::out);
if(outPut!=0)
{
cout<<"open file error"<<endl;
return false;
}

//write head to file
char *p ;
int length=poolSize;
p=poolP;
for(int i=0;i<length;i++)
{
outPut.put(*p);
p++;
}
return true;
}

bool CStringPool::loadFromFile(const string &filePath)
{
fstream input;
input.open(filePath.c_str(),ios::binary|ios::in );
if(input==NULL)
{
cout <<"open file error"<<endl;
return false;
}
int length=poolSize;
char * p=poolP;
for(int i=0;i<length;i++)
{
if(input.get(*p))
{
p++;
}

}
return true;
}

这里提供的是字符串的存储，能存储字符串就可以存储所有的类型，对于一个字符串STR如果大小大于64-8个字节，就采用，多个块存储，如 a1，a2。。。an n个块存储，第一个块a1 -> size 为字符串的大小 STR.size()，其他为0；只要找到第一个块，我们就知道这个字符串STR需要多少个块存储。