c++内存优化：二级间接索引模式内存池

 /*********************************************************
 在一些不确定内存总占用量的情形下，频繁的使用new申请内存，再通过链表
 进行索引似乎是很常规的做法。自然，也很难做到随机定位。
 下面的内存池类是用二层索引表来对内存进行大块划分，任何一个块均只需索
 引3次即可定位。
 索引数量，每索引块的分配单元数量，以及分配单元的字节长度均需为2的整数
 次幂(为了运算时的效率)
 //by:www.frombyte.com zhangyu(zhangyu.blog.51cto.com)
 *********************************************************/
 class MemTable
 {
 public:
     MemTable(void);
 public:
     ~MemTable(void);
 public:
     void CREATE(MemTableIn *in_m);
     void DEL();
     LPSTR NEW();//分配一个unit
     LPSTR NEW_CONTINUEOUS(UINT n);//用于连续分配若干个unit
     UINT NEW(UINT n); //用于可碎片方式分配若干个unit
     LPSTR GET(UINT n);//用来获得第n个分配的指针地址
     int get_totle_unitnum();
 public:
     MemTableIn in;
     LPSTR **pDouble_Indirect;
     LPSTR lpBitmap;
     LPSTR *pIndirect; 

     LPSTR m_lpFirstFree;
     int nFree[];//0表示二级索引的自由，1表示1级索引的自由，2表示块自由索引号
     INT32 m_EndBlkUseredUnits;
     int m_Vblkbytes;
     UINT m_UnitTotalNum;
     UINT m_log2Rindexs,m_log2Runits,m_log2Rbitmap,m_log2Lindexs,m_log2Lunits,m_log2Lbitmap;
     UINT m_log2UnitBytes;
     UINT m_index2ID,m_index1ID,m_UnitID;
 }; 

在一些不确定内存总占用量的情形下，频繁的使用new申请内存，再通过链表
进行索引似乎是很常规的做法。自然，也很难做到随机定位。
下面的内存池类是用二层索引表来对内存进行大块划分，任何一个块均只需索 
引3次即可定位。
索引数量，每索引块的分配单元数量，以及分配单元的字节长度均需为2的整数
次幂(为了运算时的效率)

CPP内容如下：

 /**
 * ffs - Find the first set bit in an int
 * @x:
 *
 * Description...用来统计一个整型数据的最高为1的位，后面有多少位。
 *换个说法：从最高位开始找1，找到1后，看这个二进制数据1000....000是2的几次方
 *
 * Returns:
 */
 int ffs(int x)
 {
     int r = ; 

     if (!x)
         return ;
     if (!(x & 0xffff)) {
         x >>= ;
         r += ;
     }
     if (!(x & 0xff)) {
         x >>= ;
         r += ;
     }
     if (!(x & 0xf)) {
         x >>= ;
         r += ;
     }
     if (!(x & )) {
         x >>= ;
         r += ;
     }
     if (!(x & )) {
         x >>= ;
         r += ;
     }
     return r;
 }
 LPSTR MemTree::GET(MemTreeHead *pHead,UINT n)
 {
     int t;
     LPSTR lpt;
     int i,ii;
     //判断是否直接存储
     if(n<m.rootDirectUnitNum)
         return pHead->lpRootUnit + n*m.Vsizeof;
     else
         t=n-m.rootDirectUnitNum; 

     for(i=;i<DEEP;i++)
     {
         if(t<TBT[i][])
             break;
         t-=TBT[i][];
     }
     //i便是深度，t是深度内的n
     lpt=pHead->pROOT_INDEX[i-];
     int D;
     for(ii=;ii<i;ii++)
     {
         D=t /TBT[i][ii];
         t=t % TBT[i][ii];
         lpt=*(LPSTR*)(lpt+sizeof(LPSTR)*D);
     }
     return (lpt +   t*m.Vsizeof); 

 } 

 MemTable::MemTable(void)
 {
 } 

 MemTable::~MemTable(void)
 {
     //释放所有空间
     for(int i=;i<in.nIndexNum;i++)
     {
         LPSTR *pp=pDouble_Indirect[i];
         if(pp==NULL)
             break;
         for(int ii=;ii<in.nIndexNum;ii++)
         {
             LPSTR p=pp[ii];
             if(p==NULL)
                 break;
             else
                 delete [] p;
         }
         delete [] pp;
     }
     delete [] pDouble_Indirect;
 }
 void MemTable::CREATE(MemTableIn *in_m)
 {
     //1、初始化一些参考块
     memset(&in,,sizeof(in));
     in=*in_m;
     m_UnitTotalNum=;
     nFree[]=nFree[]=nFree[]=; 

     m_Vblkbytes= in.nUnitBytes *in.nUnitPerIndex;
     m_log2Runits=ffs(in.nUnitPerIndex)-;
     m_log2Rindexs=ffs(in.nIndexNum)-;
     m_log2UnitBytes=ffs(in.nUnitBytes)-; 

     m_log2Lindexs=sizeof(UINT)*-m_log2Rindexs;
     m_log2Lunits=sizeof(UINT)*-m_log2Runits; 

     //2、初始化二级索引表
     pDouble_Indirect=new LPSTR* [in.nIndexNum];
     memset(pDouble_Indirect,,in.nIndexNum*sizeof(LPSTR));
     nFree[]=in.nIndexNum;
 }
 LPSTR MemTable::NEW()
 {
     LPSTR lpReturn;
     if(nFree[]==)//直接块用光了
     {
         if(nFree[]==)
         {
             if(nFree[]==)
                 return NULL;//写日志：达到最大分配数量 

             pIndirect=pDouble_Indirect[in.nIndexNum - nFree[]]=new LPSTR [in.nIndexNum];
             memset(pIndirect,,in.nIndexNum*sizeof(LPSTR));
             nFree[]=in.nIndexNum-; 

             lpReturn=pIndirect[]=new char[m_Vblkbytes];
             memset(lpReturn,,m_Vblkbytes);
             nFree[]=in.nUnitPerIndex-;
             m_lpFirstFree = lpReturn + in.nUnitBytes;
             nFree[]--; 

         }
         else
         {
             lpReturn=pIndirect[in.nIndexNum - nFree[]]=new char[m_Vblkbytes];
             memset(lpReturn,,m_Vblkbytes);
             nFree[]--;
             nFree[]=in.nUnitPerIndex-;
             m_lpFirstFree = lpReturn + in.nUnitBytes;
         }
     }
     else
     {
         lpReturn=m_lpFirstFree;
         nFree[]--;
         m_lpFirstFree += in.nUnitBytes;
     }
     m_UnitTotalNum++;
     return lpReturn; 

 }//by:www.frombyte.com zhangyu(zhangyu.blog.51cto.com)
 UINT MemTable::NEW(UINT n)
 {
     UINT nReturn=m_UnitTotalNum;
     for(int i=;i<n;i++)
         NEW();
     return nReturn; 

 }
 LPSTR MemTable::NEW_CONTINUEOUS(UINT n)
 {
     LPSTR lpReturn;
     if(n>in.nUnitPerIndex)
         return NULL; 

     if(nFree[]>=n)
     {
         nFree[]-=n;
         lpReturn=m_lpFirstFree;
         m_UnitTotalNum+=n;
         m_lpFirstFree += (n*in.nUnitBytes);
     }
     else
     {
         m_UnitTotalNum+=nFree[];//剩余空间保留、忽略
         nFree[]=;
         lpReturn=NEW();
         nFree[] -= (n-);
         m_lpFirstFree += ((n-)*in.nUnitBytes);
         m_UnitTotalNum += (n-);
     }
     return lpReturn;
 }
 LPSTR MemTable::GET(UINT n)
 { //by:www.frombyte.com zhangyu(zhangyu.blog.51cto.com)
     if(n>=m_UnitTotalNum)
         return NULL;//写日志：超过范围
     m_UnitID=n<< m_log2Lunits >>m_log2Lunits;
     m_index1ID=n >> m_log2Runits;
     m_index2ID=m_index1ID >> m_log2Rindexs;
     m_index1ID=m_index1ID <<m_log2Lindexs >>m_log2Lindexs; 

     return (pDouble_Indirect[m_index2ID][m_index1ID] + (m_UnitID<<m_log2UnitBytes)); 

 }
 void MemTable::DEL()
 { 

 }