内存池版本2--单线程-固定大小对象的内存池

#include "stdafx.h"
#include
#include
#include
using namespace std;

#pragma comment(lib, "winmm.lib")

template
class MemoryPool
{
public:
    MemoryPool(size_t size = EXPAND_SIZE);
    ~MemoryPool();
    inline void* alloc(size_t size); //分配一个T类型的对象
    inline void  free(void* doomed); //释放一个T类型的指针

//private:
    enum {EXPAND_SIZE = 3};
    MemoryPool* pNext;

    void ExpandFreeList(size_t num = EXPAND_SIZE);
};

template
MemoryPool::MemoryPool(size_t size = EXPAND_SIZE)
{
    ExpandFreeList(size);
}

template
MemoryPool::~MemoryPool()
{
    if (pNext != 0)
    {
        MemoryPool* ptr = pNext;
        for (; ptr != NULL; ptr = pNext)   
        {
            pNext = pNext->pNext;
            delete []ptr;
        }
    }
}

template
inline void* MemoryPool::alloc(size_t size)
{
    if (pNext == 0)
    {
        ExpandFreeList(EXPAND_SIZE);
    }

    MemoryPool* ptr = pNext;
    pNext = pNext->pNext;
    return ptr;
}

template
inline void MemoryPool::free(void* doomed)
{
    MemoryPool* ptr = static_cast* >(doomed);
    ptr->pNext = pNext;
    pNext = ptr;
}

template
void MemoryPool::ExpandFreeList(size_t num /* = EXPAND_SIZE */)
{
    size_t size = sizeof(T) > sizeof(MemoryPool*) ? sizeof(T) :  sizeof(MemoryPool*);
    MemoryPool* ptr = (MemoryPool*)(new char[size]);
    pNext = ptr;
    for (int i=0; i    {
        ptr->pNext = (MemoryPool*)(new char[size]);
        ptr = ptr->pNext;
    }

    ptr->pNext = 0;
}

class Foo2
{
public:
    Foo2(int a = 0, int b = 0):m(a), n(b) {}
    void* operator new (size_t size) {return pool->alloc(size);}
    void operator delete (void* doomed) {return pool->free(doomed);}

    static void NewMemoryPool() { pool =  new MemoryPool;}
    static void FreeMemoryPool()
    {
        if (pool)
        {
            delete pool;
        }
    }

private:
    int m;
    int n;

    static MemoryPool* pool;
};

MemoryPool* Foo2::pool = 0;

class Foo
{
public:
    Foo(int a = 0, int b = 0):m(a), n(b) {}

private:
    int m;
    int n;
};

int main()
{
    DWORD time1, time2, deltaTime;
    time1 = timeGetTime();
    for (int i=0; i<500; ++i)
    {
        Foo* ptrArray[1000];
        for (int j=0; j<1000; ++j)
        {
            ptrArray[j] = new Foo;
        }

        for (int j=0; j<1000; ++j)
        {
            delete ptrArray[j];
        }
    }

    time2 = timeGetTime();
    deltaTime = time2- time1;
    cout<
    Foo2::NewMemoryPool();
    time1 = timeGetTime();
    for (int i=0; i<500; ++i)
    {
        Foo2* ptrArray[1000];
        for (int j=0; j<1000; ++j)
        {
            ptrArray[j] = new Foo2;
        }

        for (int j=0; j<1000; ++j)
        {
            delete ptrArray[j];
        }
    }

    time2 = timeGetTime();
    deltaTime = time2- time1;
    Foo2::FreeMemoryPool();
    cout<
    return 0;
}