一个简单的 内存池 实现

Google一下“内存池”，稍微看了一下，感觉先实现一个，然后再把一些更高级的属性加进去。

 

 

1. 1. MyMem.h 
   3. /***************************************************************************/
   5. #pragma once
   7. /*内存池节点头*/
   8. typedef struct MemStr
   9. {
   10.  __int32 InUse;     /*此 内存池头结点 标记的内存块是否在使用；0，未使用；1，在使用；2刚刚被释放*/
   11.  MemStr * pNext;   /*此 内存池头结点 的前一个内存池头结点的地址*/
   12.  __int32 ThisSize;    /*此 内存池头结点 标记的内存块的大小*/
   13.  MemStr * pBefore;   /*此 内存池头结点 的后一个内存池头结点的地址*/
   14. } m_MemStr,* pMyMem;
   16. /*系统内存节点*/
   17. typedef struct MemList
   18. {
   19.  char* pThis;     /*系统内存块 的起始地址*/
   20.  MemList * pNext;   /*下一个系统内存节点的地址*/
   21. }m_MemList,* pMemList;
   24. class MyMem
   25. {
   26. public:
   28.  int nInitSize ;    /*内存池初始化大小*/
   29.  int nGrowSize ;   /*内存池，每次增长时 数值的基数，实际每次增长的大小可能是 n * nGrowSize */
   30.  char* vPointerList;  /*
   31.                    系统内存链表;保存使用new 从系统堆上申请的内存的地址列表；
   32.                   当需要释放内存给系统时，以此链表为依据。
   33.                   */
   34.     char* vStartPointer;  /*
   35.          内存池的起始地址
   36.          */
   39.  int MemInit();
   40.  int MemGrow( int , char * );
   41.  int MemDelete( );
   43.     char* MyNew( int NewSize);
   44.  int MyDelete( char * vPointer );
   45.  int MyMemset( char * vPointer , char c) ;
   46.  int MyMemcpy( char * vDestPointer , char * vSrcPointer ) ;
   49.  MyMem(void);
   50.  ~MyMem(void);
   51. };
   53. /***************************************************************************/
   MyMem.cpp
3. /***************************************************************************/
5. /*
6.  一个内存池类。
7.  此类必须使用MemInit(int size)来初始化内存的申请：从系统堆上申请指定大小的内存；之后每次内存申请都
8.  要使用MyNew(int size)来申请指定大小的内存；size<INT_MAX；否则返回NULL；
9.  如果此次申请内存大于现有的未被使用的内存，那么此类会重新申请 ( (WantedSize/nGrowSize)+1) * nGrowSize )
10.  大小的内存。并且此内存池维护的内存，直到程序关闭，不会被释放；或者调用MyDelete()来释放内存。
12.  目前版本，并未考虑自动把申请的内存区域清零；也未考虑在每次释放内存MyDelete(char ＊)释，清零。
13.  把所有的控制权限交给了调用者。清理内存，使用MyMemset(char * ,char ) 把内存区域设置为指定的
14.  字符。
16.  目标是，一个可以进行内存整理的 内存池实现。既然可以进行内存整理，那么肯定会用到类似WINDOWS
17.  系统中的HANDLE--二维指针；返回给系统的是一个二维指针，当进行了内存整理后，只会改变指针的值，
18.  不会改变指针的指针--返回给掉用者的--不会改变。那么就可以进行内存整理了，当然是在指定某些条件下
19.  自动/手动进行的。
21. */
22. #include "StdAfx.h"
23. #include "MyMem.h"
25. MyMem::MyMem(void)
26. {
27. }
29. MyMem::~MyMem(void)
30. {
31. }
32. int MyMem::MemInit()
33. {
34.  //pMyMem * 
35.  vStartPointer = NULL;
36.  if(nInitSize>sizeof(m_MemStr)&&nInitSize<INT_MAX)
37.  {
38.   vStartPointer= new char [nInitSize] ;
39.   if(vStartPointer==NULL)
40.   {
41.    return -3;
42.   }
43.  }
44.  else
45.  {
46.   if(nInitSize>INT_MAX)
47.   {
48.    return -1;//申请内存空间过大
49.   }
50.   else
51.   {
52.    return -2;//申请内存空间过小
53.   }
54.  }
56.  pMyMem p=(pMyMem)vStartPointer;
57.  p->InUse=0;
58.  p->pBefore=NULL;
59.  p->pNext=NULL;
60.  p->ThisSize=nInitSize-sizeof(m_MemStr);
62.  pMemList pL=new m_MemList;
63.  pL->pThis=vStartPointer;
64.  pL->pNext=NULL;
65.  vPointerList=(char* )pL;
67.  return 0; 
68. }
69. int MyMem::MemGrow(int nCount ,char* vBefore)
70. {
71.  if(nCount > 1024 || nCount < 1 )
72.  {
73.   return -5;
74.  }
75.  pMyMem pBefore=(pMyMem)vBefore;
76.  if(nGrowSize>sizeof(m_MemStr)&&nGrowSize<INT_MAX)
77.  {
78.   /*start 系统内存申请，同时把申请到的内存地址加入到 全局系统内存链表 */
79.   pMemList p=NULL;
80.   p=(pMemList)vPointerList;
81.   while(p->pThis!=NULL&&p->pNext!=NULL)
82.   {
83.    p=p->pNext;
84.   }
85.   pMemList pTemp=new m_MemList;
86.   char *cAdd=NULL;
87.   if(p->pThis!=NULL)
88.   {
89.    p->pNext=pTemp;
90.    cAdd=(char*) new char [ nCount * nGrowSize ] ;
91.    pTemp->pThis=cAdd;
92.    if(pTemp->pThis==NULL)
93.    {
94.     return -4;
95.    }
96.    //系统内存块链表的最后一个节点 尾指针必须为 NULL 
97.    pTemp->pNext=NULL;
98.    
99.   }
100.   else
101.   {
102.    return -3;
103.   }
104.   /*end */
106.   /*start 初始化从系统内存上新申请的内存的 内存池头*/
107.   //把刚刚申请的 系统内存块 连接到 上一个 内存池头 尾部，
108.   //并且，其他地方保证，此尾部值不能更改（不释放内存给系统）
109.   //那么从内存池链表就一定能找到此 内存池头
110.   pBefore->pNext=(pMyMem)cAdd;
112.   pMyMem pmy=(pMyMem)cAdd;
113.   pmy->InUse=0;
114.   pmy->pBefore=pBefore;
115.   pmy->pNext=NULL;
116.   pmy->ThisSize=nCount*nGrowSize-sizeof(m_MemStr);
117.   /*end */
118.  }
119.  else
120.  {
121.   if(nGrowSize>INT_MAX)
122.   {
123.    return -1;//申请内存空间过大
124.   }
125.   else
126.   {
127.    return -2;//申请内存空间过小
128.   }
129.  }
130.  return 0; 
131. }
132. int MyMem::MemDelete()
133. {
134.  pMemList p=NULL,pTemp;
135.  p=(pMemList)vPointerList;
136.  while(p->pNext==NULL)
137.  {
138.   pTemp=p->pNext;
139.   delete [] p;
140.   p=pTemp;
141.  }
142.  return 0; 
143. }
144. char*  MyMem::MyNew(int size)
145. {
146.  #pragma region 申请内存，大小值测试
147.  if(size < 1 || size > INT_MAX )
148.  {
149.   return NULL; 
150.  }
151.  #pragma endregion
153.  pMyMem p=(pMyMem)vStartPointer;
154.  int nNext=sizeof(m_MemStr)+size;
156.  #pragma   region  第一个 内存池头 The first node  of  mem pool 
158.  if(p->pNext == NULL ) 
159.  {//初始化时可能会用到，当把所有的内存使用都删除了，并且没有使用内存增长，
160.  //那么就会进入到这里来
161.     if(p ->ThisSize > nNext)
162.     {
163.      //可用，同时生成新的节点
164.      pMyMem pNewNext=NULL;
165.      pNewNext=(pMyMem)((char * )p+nNext);
166.      pNewNext->InUse=0;
167.      pNewNext->pBefore=p;
168.      pNewNext->pNext=p->pNext;
169.      
170.      pNewNext->ThisSize=p->ThisSize-nNext;
172.      p->InUse=1;
173.      p->pNext=pNewNext;
174.      p->ThisSize=size;
175.      return (char * )p+sizeof(m_MemStr);
176.     }
177.     else
178.     {//需要申请内存
179.       if(0 == MemGrow( ( (nNext/nGrowSize)+1) ,(char*)p) )
180.       {
181.        p=p->pNext;
182.        pMyMem pStart=NULL;
183.        pStart=(pMyMem)p;
184.        
186.        pMyMem pNewNext=NULL;
187.        pNewNext=(pMyMem)((char * )pStart+nNext);
188.        pNewNext->InUse=0;
189.        pNewNext->pBefore=pStart;
190.        pNewNext->pNext=pStart->pNext;
191.        pNewNext->ThisSize=pStart->ThisSize-nNext;
193.        pStart->ThisSize=size;
194.        pStart->InUse=1;
195.        pStart->pNext=pNewNext;
196.        
197.        return (char * )pStart+sizeof(m_MemStr);
198.       }
199.       else
200.       {
201.        return NULL; 
202.       }
203.     }
204.  } 
205.  #pragma   endregion 
207.  #pragma region 遍历非头结点、非最后一个节点的 内存池节点
208.   while(p ->pNext!=NULL)
209.  {//遍历所有节点，不包括最后一个 内存池头 节点
210.    if(p ->InUse != 1)
211.    {
212.       if(p ->ThisSize > nNext)
213.       {//可以分配内存
215.        pMyMem pNewNext=NULL;
216.        pNewNext=(pMyMem)((char * )p+nNext);
217.        pNewNext->InUse=0;
218.        pNewNext->pBefore=p;
219.        pNewNext->pNext=p->pNext;
220.        
221.        pNewNext->ThisSize=p->ThisSize-nNext;
223.        p->pNext=pNewNext;
224.        p->InUse=1;
225.        p->ThisSize=size;
226.        
227.        return (char * )p+sizeof(m_MemStr);
228.       }
229.       else
230.       {
231.        //不能分配内存，到下一个节点
232.       }
233.    }
234.    p = p->pNext;
235.  }
237.  #pragma endregion
239.  #pragma region 内存池头结点链表的最后一个节点 
241.  if(p ->pNext == NULL)
242.  {//到了 内存池头 链表尾节点
243.     if(p ->ThisSize > nNext)
244.     {
245.      //可用，同时生成新的节点
246.      pMyMem pNewNext=NULL;
247.      pNewNext=(pMyMem)((char * )p+nNext);
248.      pNewNext->InUse=0;
249.      pNewNext->pBefore=p;
250.      pNewNext->pNext=p->pNext;
251.      
252.      pNewNext->ThisSize=p->ThisSize-nNext;
254.      p->InUse=1;
255.      p->pNext=pNewNext;
256.      p->ThisSize=size;
257.      return (char * )p+sizeof(m_MemStr);
258.     }
259.     else
260.     {//需要申请内存
261.       if(0 == MemGrow( ( (nNext/nGrowSize)+1) ,(char*)p) )
262.       {
263.        p=p->pNext;
264.        pMyMem pStart=NULL;
265.        pStart=(pMyMem)p;
266.        
268.        pMyMem pNewNext=NULL;
269.        pNewNext=(pMyMem)((char * )pStart+nNext);
270.        pNewNext->InUse=0;
271.        pNewNext->pBefore=pStart;
272.        pNewNext->pNext=pStart->pNext;
273.        pNewNext->ThisSize=pStart->ThisSize-nNext;
275.        pStart->ThisSize=size;
276.        pStart->InUse=1;
277.        pStart->pNext=pNewNext;
278.        
279.        return (char * )pStart+sizeof(m_MemStr);
280.       }
281.       else
282.       {
283.        return NULL; 
284.       }
285.     }
286.  }
288.  #pragma endregion 
290.  return NULL; 
291. }
292. int MyMem::MyDelete(char* vPointer)
293. {
294.  #pragma region 要删除的地址的 NULL检查
295.  if(vPointer == NULL )
296.  {
297.   return -3;
298.  }
300.  #pragma endregion 
302.  /*p 节点命名为A(0) 节点；pTempBefore 节点命名为 A(-1)节点；pTempNext 节点命名为 A(1) 节点*/
303.  pMyMem p=(pMyMem)((char * )vPointer-sizeof(m_MemStr));
304.  pMyMem pTempBefore=p->pBefore;
305.  pMyMem pTempNext=p->pNext;
307.  #pragma region 检查要删除的节点，是不是系统内存块的头地址，如果是头地址，则有另外处理方法
309.  pMemList pList=NULL;
310.   pList=(pMemList)vPointerList;
311.   while(pList->pThis != NULL )
312.   {
313.    if((char*)(pList ->pThis) == (char* )p)
314.    {
315.      /*把p节点命名为A节点，那么pStartNext 节点称为 B节点 ，B节点之后如果有节点，那么就称为C 节点*/
316.      pMyMem pStartNext=NULL;
317.      pStartNext=p->pNext;
318.      if(pStartNext ->InUse != 1)
319.      {/*如果下一个节点，没有使用*/
320.         p->InUse=2;
321.         p->pNext=pStartNext->pNext;
322.         p->ThisSize+=pStartNext->ThisSize+sizeof(m_MemStr);
323.         
324.           if(pStartNext->pNext != NULL)
325.           {/*如果B节点之后有C节点，那么就需要把C节点的前一个节点的 指向 A节点，而不再是B节点*/
326.            /*A节点兼并了B节点，那么要把B节点的后一节点C的pBefore的前一个节点由原来的B，修改为A*/
327.            pStartNext->pNext->pBefore=p;
328.           }
329.           else
330.           {/*如果B节点之后没有C节点，那么就不需要把C节点的前一个节点的*/
331.            
332.           }
333.      }//end of  if(pStartNext ->InUse != 1)
334.      else
335.      {//如果下一个节点，正在使用，那么就不需要做任何与其他节点相关的操作，只要把当前节点释放了
336.         p->InUse=2;
337.      }//end of  else 
338.      return 0;
339.    }//end of if((char*)(pList ->pThis) == (char* )p)
340.    if(pList ->pNext != NULL )
341.    {
342.     pList = pList -> pNext ;
343.    }
344.    else
345.    {
346.     break;
347.    }
348.   }
350.  #pragma endregion 
352.  #pragma region 前、后节点都不是空
353.  if( pTempBefore != NULL && pTempNext != NULL )
354.  {
355.   if( ( pTempBefore->InUse == 0 || pTempBefore->InUse == 2) && 
356.    ( pTempNext->InUse == 0 || pTempNext ->InUse ==2) )
357.   {/*前后的内存块都没有被使用,但有都可能内存是被其他人释放的*/
358.     if( pTempBefore->InUse == 2 )
359.     {/*这里需要清零，暂时空在这里 ？？？*/
360.     
361.     }
362.     if( pTempNext ->InUse ==2 )
363.     {/*这里需要清零，暂时空在这里 ？？？*/
364.     
365.     }
366.     /*A(0) 节点释放了，如果A(-1)和A(1) 节点都没有使用，那么就把
367.     A(-1)节点与A(0),A(1)节点合并为同一个节点*/
369.     /*修改A(-1)节点的下一个节点 值 为 A(1)节点的 下一个节点 值；*/
370.     pTempBefore->pNext=pTempNext->pNext;
371.     
372.     /*鉴于是否自动为他人释放内存清零的策略未定义，这里的值先不改动 ？？？*/
373.     //pTempBefore->InUse=2;
375.     /*修改A(-1)节点的大小为：A(-1).size+=A(0).size+A(1).size+2*sizeof(m_MemStr)*/
376.     pTempBefore->ThisSize+=p->ThisSize+pTempNext->ThisSize+2*sizeof(m_MemStr);
377.     
378.     /*修改A(1)节点的，下一个节点A(2)节点的前一个节点为A(-1)；未修改之前的值是：A(1)*/
379.     pMyMem pTempNextNext=pTempNext->pNext;
380.     if(pTempNextNext != NULL )
381.     {
382.      pTempNextNext->pBefore=pTempBefore;
383.     }
384.   }
385.   else if ( ( pTempBefore->InUse == 0 || pTempBefore->InUse == 2) 
386.      && ( pTempNext->InUse == 1 ) )
387.   {//后面的内存正在被使用，前面的内存，未被使用或者被他人释放的
388.    if( pTempBefore->InUse == 2 )
389.    {//这里需要清零，暂时空在这里 ？？？
390.     
391.    }
392.    pTempBefore->pNext=p->pNext;
393.    //鉴于是否自动为他人释放内存清零的策略未定义，这里的值先不改动 ？？？
394.    //pTempBefore->InUse=2;
395.    pTempBefore->ThisSize+=p->ThisSize+sizeof(m_MemStr);
397.    /*修改pTempNext 的前一个节点的指针的值为pTempBefore，修改之前为p*/
398.    pTempNext->pBefore=pTempBefore;
400.   }
401.   else if ( ( pTempBefore->InUse == 1 ) && 
402.      ( pTempNext->InUse == 0 || pTempNext ->InUse ==2 ) )
403.   {//前面的内存正在被人使用，后面的内存未被使用或者被他人释放的
404.    if( pTempNext->InUse == 2 )
405.    {//这里需要清零，暂时空在这里 ？？？
406.     
407.    }
408.    p->pNext=pTempNext->pNext;
409.    //鉴于是否自动为他人释放内存清零的策略未定义，这里的值先不改动 ？？？
410.    p->InUse=2;
411.     p->ThisSize+=pTempNext->ThisSize+sizeof(m_MemStr);
413.    /*修改pTempNext 的下一个节点pNextNext的前一个节点值为p，之前为pTempNext*/
414.    pMyMem pNextNext=pTempNext->pNext;
415.    if(pNextNext != NULL )
416.    {
417.      pNextNext->pBefore=p;
418.    }
419.   }
420.   else if ( ( pTempBefore->InUse == 1 ) && ( pTempNext->InUse == 1 ) )
421.   {//前后都在被使用
422.    p->InUse=2;
423.   }
424.  }
426.  #pragma endregion 
428.  #pragma region 前、后有一个节点为空
429.  else
430.  {//有一个指针的值为空
432.   if( pTempBefore == NULL && pTempNext != NULL )
433.   {//肯定是第一个 内存池头,并且后面有其他 内存池头
434.    /************************************************************/
435.    if( ( pTempNext->InUse == 0 || pTempNext ->InUse ==2) )
436.    {//前后的内存块都没有被使用,但有都可能内存是被其他人释放的
437.      if( pTempNext ->InUse ==2 )
438.      {//这里需要清零，暂时空在这里 ？？？
439.      
440.      }
441.      p->pNext=pTempNext->pNext;
442.      //鉴于是否自动为他人释放内存清零的策略未定义，这里的值先不改动 ？？？
443.      //pTempBefore->InUse=0;
444.      p->ThisSize+=pTempNext->ThisSize+sizeof(m_MemStr);
445.      p->InUse=2;
447.      /*修改pTempNext 的下一个节点的pNextNext的前一个节点为p,之前为pTempNext*/
448.      pMyMem pNextNext=pTempNext->pNext;
449.      if(pNextNext != NULL )
450.      {
451.        pNextNext->pBefore=p;
452.      }
453.    }
454.    else if ( ( pTempNext->InUse == 1 ) )
455.    {//后面的内存正在被使用，前面的内存，未被使用或者被他人释放的
456.     p->InUse=2;
457.    }
458.    /************************************************************/
459.   }//end of if( pTempBefore == NULL && pTempNext != NULL )
460.   else if( pTempNext == NULL && pTempBefore !=NULL)
461.   {
462.    if( ( pTempBefore->InUse ==1 ) )
463.    {//前后的内存块都没有被使用,但有都可能内存是被其他人释放的
464.     p->InUse=2;
465.    }
466.    else if ( ( pTempBefore->InUse == 0 || pTempBefore->InUse == 2) )
467.    {//后面的内存正在被使用，前面的内存，未被使用或者被他人释放的
468.     if( pTempBefore->InUse == 2 )
469.     {//这里需要清零，暂时空在这里 ？？？
470.      
471.     }
472.     pTempBefore->pNext=p->pNext;
473.     //鉴于是否自动为他人释放内存清零的策略未定义，这里的值先不改动 ？？？
474.     //pTempBefore->InUse=0;
475.     pTempBefore->ThisSize+=p->ThisSize+sizeof(m_MemStr);
477.     /**/
478.     pMyMem pNextNext=p->pNext;
479.     if(pNextNext != NULL )
480.     {
481.       pNextNext->pBefore=pTempBefore;
482.     }
483.    }
484.    /***********************************************************/
485.   }//end of else if( pTempNext == NULL && pTempBefore !=NULL) 
486.   else
487.   {//肯定是第一个节点,但是理论上绝对不会出现此种情况
488.    p->InUse=2;
489.   }//end of else 
490.  }
492.  #pragma endregion
494.  return 0; 
495. }
496. int MyMem::MyMemset(char* vPointer,char c)
497. {
498.  if(vPointer != NULL )
499.  {
500.   pMyMem p=(pMyMem)((char * )vPointer-sizeof(m_MemStr));
501.   memset(vPointer,c,p->ThisSize);
502.   return 0;
503.  }
504.  else
505.  {
506.   return -1;
507.  }
508. }
509. int MyMem::MyMemcpy(char* vDestPointer,char* vSrcPointer)
510. {
511.  pMyMem pSrc=NULL,pDest=NULL;
512.  pSrc=(pMyMem)((char * )vSrcPointer-sizeof(m_MemStr));
513.  pDest=(pMyMem)((char * )vDestPointer-sizeof(m_MemStr));
514.  if(pDest->InUse==1&&pSrc->InUse==1)
515.  {
516.   if(pSrc->ThisSize<=pDest->ThisSize)
517.   {
518.    memcpy(vDestPointer,vSrcPointer,pSrc->ThisSize);
519.   }
520.   else
521.   {
522.    return -1;
523.   }
524.  }
525.  else
526.  {
527.   return -2;
528.  }
529.  return 0; 
530. }

/***************************************************************************/