[读书笔记]STL源码剖析

内存池STL实现：
内存池(Memory Pool)是一种内存分配方式。 通常我们习惯直接使用new、malloc等API申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。
　　内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是尽量避免了内存碎片，使得内存分配效率得到提升。
　　在内核中有不少地方内存分配不允许失败. 作为一个在这些情况下确保分配的方式, 内核开发者创建了一个已知为内存池(或者是 "mempool" )的抽象. 一个内存池真实地只是一类后备缓存, 它尽力一直保持一个空闲内存列表给紧急时使用
free-lists 分别管理大小为 8，16，24，32，40，56，64，72，80，88，96，104，112，120，128 bytes 大小的小额区块，所以当申请小额内存时，内存的需求量会被上调至 8 的倍数，以便于管理。
1、如果freelist上有用户所申请的空间大小的位置上有未用空间，则直接分配给用户
2、如果freelist上该大小的未用块没有了，则从内存池中分配20个该大小的快，连接到freelist上，然后分配一个给用户。
3、如果内存池不足以分配20个块，则能分配多少就分配多少；如果一个都不能分配，1）首先把内存池剩下的空间交给对应的freelist 2）然后用malloc申请新的内存池空间。
4、如果malloc申请失败，则查找freelist更大的位置上有没空的，如有则直接分配一个给用户。如没有则呼叫第一级配置器。。。
STL内存管理：如申请的内存大于128字节则直接申请，如小于就*8后使用内存池申请。

using namespace std;
class Block
{
friend class MemPool;
size_t size;//块大小，字节为单位
bool use;
char *data;//初始为NULL，代表还没分配空间
public:
Block(){use=false;data=NULL;}
};

class MemPool;
class List
{
friend class Test;
friend class MemPool;
size_t size;//本表所存块的大小
size_t freeBlock;//表示本List还有多少个空的Block
Block list[20];//每个列表最多有20个block
public:
List(){freeBlock=0;}
};

struct UserMem
{
size_t size;//此次申请的空间大小
char* p;//空间的开始指针
};

class MemPool
{
friend class Test;
List freeList[16];//freelist有15种不同的块大小，从8bytes 到128bytes
char *freeStart;//当前内存池的开头指针
size_t poolSize;//内存池的余量
char* poolStart[10];//新建内存池开始的地址，用于最后删除内存池时delete用，最多10个
public:
MemPool();
UserMem myMalloc(size_t size);//客户申请空间函数；默认size为8的倍数
void myFree(const UserMem &usermem);
~MemPool();
};

MemPool::~MemPool(){
//清楚所有内存池空间
for(int i=0;i<10;++i){
if(poolStart[i]!=NULL)
delete []poolStart[i];
}
}
MemPool::MemPool(){
freeStart=NULL;
poolSize=0;
int tmp=8;
//初始化size
for(int i=0;i<16;++i){
freeList[i].size=tmp;
tmp+=8;
}
//初始化内存池开始地址为NULL，没分配地址的内存池地址为NULL
for(int i=0;i<10;++i){
poolStart[i]=NULL;
}
}

UserMem MemPool::myMalloc(size_t size){
//查找freelist上有没可用的块
List *thisList=&freeList[size/8-1];//这个大小的块所在的list
UserMem returnVal;
//freelist上有可用的
if(thisList->freeBlock>0){
for(int i=0;i<20;++i){
if(thisList->list[i].use || thisList->list[i].data==NULL){continue;}
else{//找到还没用的Block
thisList->list[i].use=true;
thisList->freeBlock--;
returnVal.size=size;
returnVal.p=thisList->list[i].data;
return returnVal;
}
}
}

//freelist上没有可用的
//从内存池调配空间给freelist
if(poolSize>=size*5){
//直接拨5个
int count=0;
for(int i=0;i<20;++i){
if(count<5 && thisList->list[i].data==NULL && poolSize>0){
thisList->list[i].data=freeStart;
freeStart+=size;
poolSize-=size;
thisList->freeBlock++;
count++;
}
}
return (myMalloc(size));
}else if(poolSize>=size){
//给1个或以上
int nHasSize=poolSize/size;//可以给nHasSize个
int count=0;
for(int i=0;i<20;++i){
if(count<nHasSize && thisList->list[i].data==NULL && poolSize>0){
thisList->list[i].data=freeStart;
freeStart+=size;
poolSize-=size;
thisList->freeBlock++;
count++;
}
}
return (myMalloc(size));
}else{
//一个都不能给，把内存池剩余容量给freelist
cout<<"内存池还剩下"<<poolSize<<"个字节的内存"<<endl;
if(poolSize>0){

List *returnToList=&freeList[poolSize/8-1];
for(int i=0;i<20;++i){
if(returnToList->list[i].data==NULL){
returnToList->list[i].data=freeStart;
returnToList->freeBlock++;
poolSize-=returnToList->size;
break;
}
}
}
cout<<"内存池还剩下"<<poolSize<<"个字节的内存"<<endl;
//给内存池new10个size给内存池，然后调用自己。
freeStart=new char[size*10];
if(freeStart==NULL){
cout<<"new failed"<<endl;
return (UserMem){0,NULL};
}
for(int i=0;i<10;++i){
if(poolStart[i]==NULL){
poolStart[i]=freeStart;
break;
}
}
poolSize+=size*10;
return (myMalloc(size));
}
}

void MemPool::myFree(const UserMem &usermem){
List *thisList=&freeList[usermem.size/8-1];
int index=((int)usermem.p-(int)thisList->list[0].data)/usermem.size;
thisList->list[index].use=false;
thisList->freeBlock++;
}

class Test
{
public:
static void test(const MemPool &memPool);
static UserMem useMem(MemPool &memPool,size_t size);
static void freeMem(MemPool &memPool,const UserMem &userMem);
};
void Test::test(const MemPool &memPool){//内存池的测试函数
//打印内存池的大小
cout<<"内存池大小为："<<memPool.poolSize<<endl;
//打印freelist的使用情况
for(int i=0;i<16;++i){
const List *thisSizeList=&memPool.freeList[i];
//打印此大小的list的信息
cout<<"大小为"<<thisSizeList->size<<"的表还剩"<<thisSizeList->freeBlock<<"个块可用"<<endl;
}
}

UserMem Test::useMem(MemPool &memPool,size_t size){
UserMem rVal=memPool.myMalloc(size);
char *p=rVal.p;
if(p!=NULL){
memset(p,'a',size-1);
p[size-1]='\0';
cout<<p<<endl;
}else{
cout<<"error"<<endl;
}
return rVal;
}

void Test::freeMem(MemPool &memPool,const UserMem &userMem){
memPool.myFree(userMem);
}

int main()
{
MemPool mem;
Test::test(mem);
Test::freeMem(mem,Test::useMem(mem,8));
Test::useMem(mem,128);
Test::test(mem);
return 0;
}

list：

就算列表为空，也回存在一个空空节点，end()就是指向这个空节点。这个空节点往后连接到最后一个元素，往前连接到begin()，因此用一个成员endNode来记录这个空节点的迭代器，就可以方便的实现很多操作。如begin()为endNode->next()；end()为endNode等等。并且此设计符合STL的前闭后开的规定，比如一个函数要求传入一个迭代器区间，则(beging(),end())，表示所有元素。

deque：
双向队列也是一个随机存取容器。但与vector不同，它的元素并不存储在连续的内存中，只是存储在分段连续的内存中，就是连接多段连续内存。每次连续空间不足时，并不需要搬运数据，只需在寻找一个新的连续内存，并把它连接到之前的内存上就可以了。这个可以避免搬运内存而带来的低效，但代价是复杂的迭代器设计。
deque使用一块连续地址的map存放各段连续的缓冲空间的头指针。缓冲空间才是deque真正的数据存储区。