C++实现简单的内存池

没有考虑线程安全，只是简单的实现了内存池
功能：第一次先申请一大片内存，然后分成小块，每次分配给应用程序这小块内存，当内存不够了又继续向系统申请一大片内存
直接晒代码

MemPool.h

#include <iostream>
template<typename T>
class MemPool
{
public:
    MemPool(){}
    MemPool(T data) :data(data){}
    //这两个函数编译器就默认处理成static函数
    void *operator new(size_t size)
    {
        MemPool *pCur;
        if (!pHead)//如果内存不够了，向系统申请内存
        {
            int allocsize = size * MEM_POOL_SIZE;
            cout << "第" << ++count << "向系统申请了" << allocsize << "字节内存" << endl;
            pHead = (MemPool*)new char[allocsize];
            for (pCur = pHead; pCur < pHead + MEM_POOL_SIZE - 1;++pCur)
                pCur->pNext = pCur + 1;
            pCur->pNext = NULL;
        }
        pCur = pHead;
        pHead = pHead->pNext;
        return pCur;//这里只是把其中一片内存给用户了，用户并不能通过 ->pNext 得到下一片内存★★★★★
    }
    void operator delete(void *ptr)
    {
        cout << "MemPool delete" << endl;
        if (!ptr) return;
        MemPool *cur = (MemPool*)ptr;
        cur->pNext = pHead;
        pHead = cur;
    }
public:
    MemPool *pNext;
    static const unsigned int MEM_POOL_SIZE = 10;
    static MemPool *pHead;
    static int count;
    T data;
};
template<typename T>
static MemPool<T> *initNull()
{
    cout << "initNull" << endl;
    return NULL;
}
template<typename T>
MemPool<T> *MemPool<T>::pHead = initNull<T>();
template<typename T>
int MemPool<T>::count = 0;

Queue.h

#include "Mempool.h"
template<typename T>
class Queue
{
public:
    Queue()
    {
        prear = pfirst = NULL;
    }
    ~Queue()
    {
        MemPool<T> *pcur = pfirst;
        while (pcur != prear)
        {
            pfirst = pfirst->pNext;
            delete pcur;
            pcur = pfirst;
        }
    }
    T front()
    {
        if (!pfirst)
            return NULL;
        return pfirst->data;
    }
    T back()
    {
        if (!prear)
            return NULL;
        return prear->data;
    }
    void push(const T &d)
    {
        /*prear = new MemPool<T>(d);
        if (!pfirst)
            pfirst = prear;*/
        MemPool<T> *p = new MemPool<T>(d);
        if (!prear)
            prear = pfirst = p;
        else
        {
            prear->pNext = p;
            prear = p;
        }
    }
    void pop()
    {
        if (pfirst == prear)
        {
            delete pfirst;
            pfirst = prear = NULL;
        }
        else
        {
            MemPool<T> *pFree = pfirst;
            pfirst = pfirst->pNext;
            delete pFree;
        }
    }
    bool empty()
    {
        if (prear == NULL && pfirst == NULL)
            return true;
        return false;
    }
private:
    MemPool<T> *prear;
    MemPool<T> *pfirst;
};

main

#include "Queue.h"
#include <queue>
using namespace std;

int main()
{
    Queue<int> q1;
    queue<int> q2;

    for (int i = 0; i < 22; i++)
    {
        q1.push(i);
        q2.push(i);
    }

    while (!q1.empty())
    {
        cout << q1.front() << " ";
        q1.pop();
    }

    while (!q2.empty())
    {
        cout << q2.front() << " ";
        q2.pop();
    }
    cout << endl;

    system("pause");
    return 0;
}