通用内存池

#include
#include

/*
目的：实现一个通用的内存池

过程：通过 MEM_POOL（内存池类），中的alloc实现其他类的new，dealloc实现其他类的delete，
使用内存池的类，在一个类下，使用同一个内存池。（通过static关键字来进行实现：单例模式，本次实现线程安全），
*/

const int MEM_SIZE = 10;

template
class MEM_POOL
{
public:
static MEM_POOL* getInstance()//单例模式（线程安全）
{
if(ppm == NULL)
{
ppm = new MEM_POOL();
}
return ppm;
}

void * alloc(size_t size)//申请大块空间向外部提供小空间
{
    if(pool == NULL)
    {
        pool = (Node *) new char[size*MEM_SIZE]();
        Node * pcur = pool;
        for(pcur;pcur < pool + MEM_SIZE + 1;pcur = pcur + 1)
        {
            pcur -> pnext = pcur + 1;
        }
        pcur -> pnext = NULL;
    }
    void * rt = pool;
    pool = pool -> pnext;
    return rt;
}

void  dealloc(void * ptr)//回收空间
{
    Node * nptr = (Node *) ptr;
    if(nptr == NULL)
    {
        return ;
    }
    nptr -> pnext = pool;
    pool = nptr;
}

private:
MEM_POOL()
{
pool = NULL;
}
MEM_POOL(const MEM_POOL&);
struct Node
{
public:
Node(T value = T())
:val(value),pnext(NULL)
{}
public:
T val;
Node * pnext;
};
Node * pool;//指向第一个可向外提供的空间，为null时再次使用alloc将再次申请大片空间。
static MEM_POOL * ppm;//确保单例
};

template
MEM_POOL * MEM_POOL:: ppm = NULL;

class Student
{
public:
Student(std::string name,std::string id,int ag)
:mname(name),mid(id),age(ag)
{}

void * operator new(size_t size)//对new进行重载
{
    return pmm->alloc(size);
}

void operator delete(void * ptr)//对delete进行重载
{
    pmm -> dealloc(ptr);
}

private:
std::string mname;
std::string mid;
int age;
static MEM_POOL * pmm; //实现与 MEM_POOL进行对接
};

MEM_POOL * Student :: pmm = MEM_POOL::getInstance();

int main()
{
Student* pstu1 = new Student(“zhangsan”, “001”, 20);
Student* pstu2 = new Student(“lisi”, “002”, 19);
Student* pstu3 = new Student(“zhangsan”, “001”, 20);
Student* pstu4 = new Student(“lisi”, “002”, 19);

delete pstu1;
delete pstu2;
delete pstu3;
delete pstu4;
return 0;

}