代碼實現(xiàn)：
#pragma once
#include<iostream>
using namespace std;
//用鏈表來實現(xiàn)內(nèi)存池，每一個結(jié)點都掛有一塊內(nèi)存
template<typename T>
class ObjectPool
{
       struct BlockNode         //每一個結(jié)點類型
       {
              void* _memory;        //指向一塊已經(jīng)分配的內(nèi)存
              BlockNode * _next;    //指向下一個結(jié)點
              size_t _objNum;       //記錄這塊內(nèi)存中對象的個數(shù)
              BlockNode(size_t objNum)
                     :_objNum(objNum)
                     , _next(NULL)
              {
                     _memory = malloc(_objNum*_itemSize);
              }
              ~BlockNode()
              {
                     free(_memory);
                     _memory = NULL;
                     _next = NULL;
                     _objNum = 0;
              }
       };
protected:
       size_t _countIn;      //當(dāng)前結(jié)點的在用的計數(shù)
       BlockNode* _frist;    //指向鏈表的頭
       BlockNode* _last;     //指向鏈表的尾
       size_t _maxNum;        //記錄內(nèi)存塊最大的容量
       static size_t _itemSize;   //單個對象的大小
       T* _lastDelete;        //指向最新釋放的那個對象的空間
public:
       ObjectPool(size_t initNum = 32, size_t maxNum = 100000)  //默認(rèn)最開始內(nèi)存塊有32個對象，一個內(nèi)存塊最大有maxNum個對象
              :_countIn(0)
              , _maxNum(maxNum)
              , _lastDelete(NULL)
       {
              _frist = _last =new BlockNode(initNum);   //先開辟一個結(jié)點，這個結(jié)點里面的內(nèi)存塊能夠存放initNum個對象
       }
       ~ObjectPool()
       {
              Destory();
       }
       T* New()                   //分配內(nèi)存
       {
              if (_lastDelete)         //先到釋放已經(jīng)用完并且換回來的內(nèi)存中去找
              {
                     T* object = _lastDelete;
                     _lastDelete = *((T**)_lastDelete);  //將_lastDelete轉(zhuǎn)換成T**，*引用再取出來T*，也就是取出前T*類型大小的單元
                     return new(object) T();        //把這塊內(nèi)存用從定位new初始化一下
              }
              //判斷還有沒有已經(jīng)分配的內(nèi)存且還未使用,如果沒有內(nèi)存的話就要再分配內(nèi)存
              if (_countIn >= _last->_objNum)     //大于等于表示沒有了，這時候就要分配內(nèi)存了
              {
                     size_t size =2*_countIn;
                     if (size > _maxNum)            //塊的最大大小不能超過maxNum，如果沒超過就以二倍增長
                           size = _maxNum;
                     _last->_next = new BlockNode(size);
                     _last = _last->_next;
                     _countIn = 0;
              }
              //還有已經(jīng)分配好的未被使用的內(nèi)存
              T* object =(T*)（(char*)_last->_memory + _countIn*_itemSize）;
              _countIn++;
              return new(object) T();        //將這塊空間用重定位new初始化一下
       }
       void Destory()
       {
              BlockNode *cur = _frist;
              while (cur)
              {
                     BlockNode* del = cur;
                     cur = cur->_next;
                     delete del;            //會自動調(diào)用~BlockNode()
              }
              _frist = _last = NULL;
       }
       void Delete(T* object)          //釋放內(nèi)存
       {
              if (object)
              {
                     object->~T();       
                     *((T**)object) = _lastDelete;      //將_lastDelete里面保存的地址存到tmp指向空間的前T*大小的空間里面
                     _lastDelete = object;
              }
       }
protected:
       static size_t GetItemSize()
       {
              if (sizeof(T)>sizeof(T*))
              {
                     return sizeof(T);
              }
              else
              {
                     return sizeof(T*);
              }
       }
};
template<typename T>
size_t ObjectPool<T>::_itemSize =ObjectPool<T>::GetItemSize();          //類外初始化靜態(tài)變量_itemSize