简单的内存池实现

1.以队列为例，首先创建一个队列，其中new delete 都是调用系统的

class Node
{
public:
Node(int data = 0) :mdata(data), mnext(NULL){}
int mdata;
Node *mnext;
};


class Queue
{
public:
Queue()
{
mfirst = new Node;
mend = mfirst;
}
void Addque(int data)
{
Node *tmp = new Node(data);
mend->mnext = tmp;
mend = tmp;
}
void Delque()
{
Node *p = mfirst->mnext;
if (p == NULL)
{
return;
}
if (p->mnext == NULL)
{
mend = mfirst;
}
mfirst->mnext = p->mnext;
delete p;
}
~Queue(){}
private:
Node *mfirst;
Node *mend;
};


int main()
{
Queue que;
que.Addque(2);
que.Addque(3);
que.Addque(4);
que.Delque();
return 0;

}

如上代码，每次Queue new 或 delete一个结点的时候，都会从用空间的堆中申请空间，如果堆中空间不足了，在向系统批发

如果我们对程序的及时性要求比较高，这样申请空间的效率太慢了，那么我们就可以使用内存池

基本思想，一次性向系统申请1024个Node结点的空间，每次程序申请空间或释放空间都是对这个链表的操作了，这样需要重载结点Node的new delete 函数

#define SIZE 1024
class Node
{
public:
Node(int data = 0) :mdata(data), mnext(NULL){}
void *operator new(size_t size)
{
Node *pur;
         if (mfree == NULL)
         {
mfree = (Node *)new char[size*SIZE];
for (pur = mfree; pur < mfree+SIZE - 1; ++pur)
{
pur->mnext = pur + 1;
}
pur->mnext = NULL;
         }
pur = mfree;
mfree = mfree->mnext;
return pur;
}
void operator delete(void *ptr)
{
if (ptr == NULL)
{
return;
}
Node *p = (Node *)ptr;
p->mnext = mfree;
mfree = p;
}
int mdata;
Node *mnext;
static Node *mfree;
};
Node*Node::mfree = NULL;

这样，Queue每次申请Node结点的时候，都是从mfree管理的这一条链表上取结点

删除结点的时候，都是把结点在归还到mfree管理的链表上，这样能实现高效率

}