散分，顺便发个开源的类，无聊的时候一看,该如何解决

#pragma once

#include <stack>
#include <crtdbg.h>

using namespace std;

// 对于大量频繁创建和销毁的对象，存在过多的内存分配/释放操作，
// 使用一个空闲列表可以大大减少内存操作的频度，即：
//     当需要创建对象时，从空闲列表头中提取一个，如果空闲列表为空，则创建对象
//     当需要销毁对象时，将其放到空闲列表尾，如果空闲列表已满，则销毁对象
// 实际上，本类还使用了Over-eager evaluation技术，即：
//     每次需要创建对象时，都预计将会需要更多的对象，所以批量创建，返回第一个，
// 并将剩下的放到空闲列表中，等待预计中的创建请求
template<class T>
class FreeList {
public:
    // 构造函数，传入列表大小，和批量分配的个数
    FreeList(UINT maxFree, UINT batchNew) : 
        m_maxFree(maxFree), m_batchNew(batchNew), m_batchNewList(NULL) {
        m_batchNewList = new T*[batchNew];
    };
    // 析构函数，清空列表，删除批量创建列表
    ~FreeList() {
        /*
        list<T*>::iterator it = m_freeList.begin();
        for(; it!= m_freeList.end(); ++it) {
            delete (*it);
            (*it) = NULL;
        }
        m_freeList.clear();
        */
        while(!m_freeList.empty()) {
            T* obj = m_freeList.top();
            m_freeList.pop();
            delete obj;
        }
        delete [] m_batchNewList;
        m_batchNewList = NULL;
    };

public:
    // 分配并初始化
    T* Allocate() {
        // 如果空闲列表非空，则从列表头部提取一个
        // 如果为空，则批量创建
        T* obj = NULL;
        if (!m_freeList.empty()) {
            obj = m_freeList.top();
            _ASSERTE(_CrtIsValidHeapPointer(obj));
            m_freeList.pop();
        }
        else {
            // Over-eager evaluation, 每当需要new的时候，预计会需要更多
            // 所以一次产生多个，以减少调用new的次数
            for(UINT j = 0; j < m_batchNew; ++j) {
                m_batchNewList[j] = new T();
                _ASSERTE(_CrtIsValidHeapPointer(m_batchNewList[j]));
                if(!m_batchNewList[j]) {
                    printf("ATS::Allocate() out of memory!!! %d", GetLastError()); 
                    break;
                }
            }
            if(j > 0) {
                // 留着第一个返回，把后面的全部加到m_freeList中
                obj = m_batchNewList[0];
                for(UINT i = 1; i < j; ++i) {
                    m_freeList.push(m_batchNewList[i]);
                }
            }
        }

        // 初始化，为以后的使用作准备
        if(obj)
            obj->Init();

        return obj;
    };
    // 反初始化并释放
    void Release(T* obj) {
        if(!obj)
            return;
        _ASSERTE(_CrtIsValidHeapPointer(obj));

        // 首先调用反初始化，释放对象可能关联的资源
        obj->Uninit();

        // 如果空闲列表未满，就放到空闲列表尾
        // 如果已满，就销毁对象
        if(m_freeList.size() < m_maxFree)
            m_freeList.push(obj);
        else {
            delete obj;
            obj = NULL;
        }
    };
private:
    // 空闲的对象列表
    stack<T*> m_freeList;
    // 空闲对象的最大个数
    const UINT m_maxFree;
    // 批量创建的对象指针列表
    T** m_batchNewList;
    // 批量创建的对象个数
    const UINT m_batchNew;
};