简易内存池

#include

/*
new
1.开辟内存
2.初始化
delete
1.释放资源
2.释放内存
/
/
new
1.开辟内存
operator new 系统
2.调用构造函数
delete
1.调用析构函数
2.释放对象的内存
operator delete 系统
*/

/*
自主的内存管理机制 ：通过对new，delete进行重载来实现。
*/

/*
系统允许new，delete进行重载
/
template
class Queue
{
public:
Queue()
{
pfront = ptail = new QueueItem();//使用带头节点的单链表实现头插，统一操作，方便，浪费一个结点问题不大
}
~Queue()
{
QueueItem pCur = pfront;
QueueItem* pNext;
while(pCur != NULL)
{
pNext = pCur -> pnext;
delete pCur;
pCur = pNext;
}
pfront = ptail = NULL;
}
void push(T val)
{
QueueItem* pnewitem = new QueueItem(val);
ptail -> pnext = pnewitem;
ptail = ptail -> pnext;
}
bool emtpy()
{
return (ptail == pfront) && (pfront != NULL);
}
void pop()
{
if(emtpy())
{
throw std::exception(“Queue is empty!”);
}
QueueItem* pdelete = pfront -> pnext;
pfront -> pnext = pdelete -> pnext;
delete pdelete;
}
T front()
{
if(emtpy())
{
throw std::exception(“Queue is empty!”);
}
return pfront -> pnext -> mdata;
}
T back()
{
if(emtpy())
{
throw std::exception(“Queue is empty!”);
}
return ptail -> mdata;
}
private:
class QueueItem
{
public:
QueueItem(T val = T())
:mdata(val),pnext(NULL)
{}
void * operator new (size_t size)
{
if(poor == NULL)//没有空间的话进行申请，最后一个内存片指针域置为NULL
{
poor =(QueueItem*) new charsize * 10;//将10次内存(系统)申请变成1次和 10次(用户)
QueueItem* pcur = poor;
for(pcur;pcur < poor + 10 - 1;pcur = pcur + 1)//参考静态链表
{
pcur -> pnext = pcur + 1;
}
pcur -> pnext = NULL;
}
QueueItem* rt = poor;//以头删的方式对外提供空间
poor = poor -> pnext;
return rt;
}
void operator delete (void* ptr)
{
if(ptr == NULL)return ;
QueueItem* pptr = (QueueItem*) ptr;//采取头插的方式
pptr -> pnext = poor;
poor = pptr;
}
public:
T mdata;
QueueItem* pnext;
};
QueueItem* pfront;
QueueItem* ptail;
static QueueItem* poor;
};

template
typename Queue::QueueItem* Queue::poor = NULL;

int main()
{
Queue que;

for (int i = 0; i < 3; i++)
{
	que.push(i + 1);
}

int rt = que.front();
que.pop();

std::cout << "rt:" << rt << std::endl;
return 0 ;

}