内存池的实现:数据结构部分是用的静态链表
类和模板实现
代码示例:
#include <iostream>
using namespace std;
const int MEM_POOL_SIZE = 10;
template<typename T>
class Queue
{
public:
class QueueItem; //嵌套类的前置声明
Queue(); //构造函数
~Queue(); //析构函数
void Push(T val);//入队
void Pop(); //出队
T Getfront(); //获取队头结点
T Getback(); //获取队尾结点
bool IsEmpty(); //判空
void Show(); //打印
private:
class QueueItem //结点类
{
public:
QueueItem(T val = T()); //结点构造
~QueueItem(); //结点析构
void* operator new(size_t size);//重载new
void operator delete(void* ptr);//重载delete
public:
T mdata;
QueueItem* pnext;
static QueueItem* pool;
};
QueueItem* pfront;
QueueItem* prear;
};
//类外初始化静态成员变量
template<typename T>
typename Queue<T>::QueueItem* Queue<T>::QueueItem::pool = NULL;
//类外实现构造函数
template<typename T>
Queue<T>::Queue()
{
pfront = prear = new QueueItem();
}
//类外实现析构函数
template<typename T>
Queue<T>::~Queue()
{
QueueItem* pCur = pfront;
QueueItem* pNext = pCur;
while (pCur != NULL)
{
pNext = pCur->pnext;
delete pCur;
pCur = pNext;
}
pfront = prear = NULL;
}
//类外实现入队
template<typename T>
void Queue<T>::Push(T val)
{
QueueItem* pNewNode = new QueueItem(val);
prear->pnext = pNewNode;
prear = prear->pnext;
}
//类外实现出队
template<typename T>
void Queue<T>::Pop()
{
if (!IsEmpty())
{
QueueItem* pCur = pfront->pnext;
pfront->pnext = pCur->pnext;
delete pCur;
}
else
{
throw exception("Queue Empty");//如果为空就抛出异常
}
}
//类外实现获取队头结点函数
template<typename T>
T Queue<T>::Getfront()
{
if (!IsEmpty())
{
return pfront->pnext->mdata;
}
else
{
throw exception("Queue Empty");
}
}
//类外实现获取队尾结点函数
template<typename T>
T Queue<T>::Getback()
{
if (!IsEmpty())
{
return prear->mdata;
}
else
{
throw exception("Queue Empty");
}
}
//类外实现判空函数
template<typename T>
bool Queue<T>::IsEmpty()
{
return pfront == prear;
}
//类外实现打印函数
template<typename T>
void Queue<T>::Show()
{
QueueItem* pCur = pfront->pnext;
while (pCur != NULL)
{
cout << pCur->mdata << " ";
pCur = pCur->pnext;
}
cout << endl;
}
//类外实现嵌套类的构造函数
template<typename T>
Queue<T>::QueueItem::QueueItem(T val)
{
mdata = val;
pnext = NULL;
}
//类外实现嵌套类的析构函数 析构函数是空函数
template<typename T>
Queue<T>::QueueItem::~QueueItem(){}
//类外实现new的重载
template<typename T>
void* Queue<T>::QueueItem::operator new(size_t size)
{
if (pool == NULL)
{
int allocsize = size*MEM_POOL_SIZE;
pool = (QueueItem*)new char[allocsize];
QueueItem* pCur = pool;
for (pCur; pCur < pool + MEM_POOL_SIZE - 1; ++pCur)
{
pCur->pnext = pCur + 1;
}
pCur->pnext = NULL;
}
QueueItem* rt = pool;
pool = pool->pnext;
return rt;
}
//类外实现delete的重载
template<typename T>
void Queue<T>::QueueItem::operator delete(void* ptr)
{
if (ptr == NULL)
return;
QueueItem* pCur = (QueueItem*)ptr;
pCur->pnext = pool;
pool = pCur;
}
int main()
{
Queue<int> que;
for (int i = 0; i < 15; ++i)
{
que.Push(i + 1);
}
que.Show();
cout << que.Getfront() << endl;
cout << que.Getback() << endl;
cout << que.IsEmpty() << endl;
que.Pop();//出队每次出第一个数据结点
que.Show();
return 0;
}
运行结果: