适用于类和结构体的内存池模板类

   原理很简单，就是先开辟n个数据块，每个数据块的前四个字节next_id表示下一个可用的数据块的编号。该内存池类中有一个成员m_firstId, 表示第一个可用的数据块的编号，然后在申请内存的时候，根据这个编号，返回对应的数据块的地址。在将申请的内存块A归还给内存池时,根据其地址确定其所在的内存块编号。然后将该内存块的next_id改为m_firstId,将m_firstId改为该内存块的id。

Mempool.h

1. #ifndef _MEM_POOL_H_
   
2. #define _MEM_POOL_H_
   
3. 
   
4. #include "Lock.hpp"
   
5. 
   
6. template<class T>
   
7. class Mempool
   
8. {
   
9. public:
   
10.     struct BlockNode
    
11.     {
    
12.         int        next_id;
    
13.         T          data;
    
14.     };
    
15. 
    
16. public:
    
17.     Mempool(int nCount)
    
18.         :m_nCount(nCount)
    
19.         ,m_firstId(-1)
    
20.         ,m_NodeHead(NULL)
    
21.         ,m_pNode(NULL)
    
22.     {
    
23.         m_NodeHead = (BlockNode*)malloc(sizeof(BlockNode) * m_nCount);
    
24.         if(m_NodeHead == NULL)
    
25.         {
    
26.             return;
    
27.         }
    
28. 
    
29.         memset(m_NodeHead, 0, sizeof(BlockNode) * m_nCount);
    
30. 
    
31.         m_pNode = new BlockNode*[m_nCount];
    
32. 
    
33.         memset(m_pNode, 0, sizeof(BlockNode*) * m_nCount);
    
34. 
    
35.         BlockNode* temp = m_NodeHead;
    
36. 
    
37.         for(int i = 0; i < m_nCount; ++i)
    
38.         {
    
39.             m_pNode[i] = temp;
    
40.             temp->next_id = i + 1;
    
41.             temp = (BlockNode*)((char*)temp + sizeof(BlockNode));
    
42. 
    
43.             if(i == m_nCount - 1)
    
44.             {
    
45.                 temp->next_id = -1;
    
46.             }
    
47.         }
    
48. 
    
49.         m_firstId = 0;
    
50.     }
    
51. 
    
52.     ~Mempool()
    
53.     {
    
54.         if(m_NodeHead)
    
55.         {
    
56.             free(m_NodeHead);
    
57.             m_NodeHead = NULL;
    
58.         }
    
59. 
    
60.         if(m_pNode)
    
61.         {
    
62.             delete []m_pNode;
    
63.             m_pNode = NULL;
    
64.         }
    
65.     }
    
66. 
    
67.     inline void* mallocMemBuf()
    
68.     {
    
69.         AutoLock lock(&m_lock);
    
70. 
    
71.         void* p = NULL;
    
72.         if(m_firstId != -1 && m_firstId < m_nCount)
    
73.         {
    
74.             p = (void*)&(m_pNode[m_firstId]->data);
    
75.             m_firstId = m_pNode[m_firstId]->next_id;
    
76.         }
    
77.         else
    
78.         {
    
79.             p = malloc(sizeof(T));
    
80.         }
    
81. 
    
82.         return p;
    
83.     }
    
84. 
    
85.     inline void freeMemBuf(void* pNode)
    
86.     {
    
87.         AutoLock lock(&m_lock);
    
88. 
    
89.         if((pNode >= (char*)m_NodeHead) && (pNode <= (char*)m_NodeHead + sizeof(BlockNode)* m_nCount))
    
90.         {
    
91.             for(int i = 0; i < m_nCount; ++i)
    
92.             {
    
93.                 if(pNode == (void*)&(m_pNode[i]->data))
    
94.                 {
    
95.                     m_pNode[i]->next_id = m_firstId;
    
96.                     m_firstId = i;
    
97.                     return;
    
98.                 }
    
99.             }
    
100.         }
     
101. 
     
102.         free(pNode);
     
103.     }
     
104. 
     
105. private:
     
106.     int                m_nCount;            //the block count
     
107.     int                m_firstId;            //the first free block id
     
108.     BlockNode*         m_NodeHead;            //the head of the list
     
109.     BlockNode**        m_pNode;            //the pointer array
     
110.     Lock               m_lock;    
     
111. };
     
112. 
     
113. #endif

运用实例

1. #include <iostream>
   
2. #include <time.h>
   
3. #include "Mempool.hpp"
   
4. 
   
5. using namespace std;
   
6. 
   
7. #define _MEM_POOL_
   
8. 
   
9. class Test
   
10. {
    
11. public:
    
12.     Test()
    
13.         :a(0)
    
14.         ,b(0)
    
15.     {
    
16.         count1++;
    
17.         //cout << "Test constructor!" << endl;
    
18.     }
    
19. 
    
20.     ~Test()
    
21.     {
    
22.         count2++;
    
23.         //cout << "Test destructor!" << endl;
    
24.     }
    
25. 
    
26.     void setA(int _a)
    
27.     {
    
28.         a = _a;
    
29.     }
    
30. 
    
31.     void setB(int _b)
    
32.     {
    
33.         b = _b;
    
34.     }
    
35. 
    
36.     void show()
    
37.     {
    
38.         cout << "a = " << a << " b = " << b << endl;
    
39.     }
    
40. 
    
41. #ifdef _MEM_POOL_
    
42. 
    
43.     inline void* operator new(unsigned int nSize )
    
44.     {
    
45.         if( mempool == NULL )
    
46.         {
    
47.             return malloc( nSize );
    
48.         }
    
49.         return mempool->mallocMemBuf( );
    
50.     };
    
51.     inline void operator delete(void* p)
    
52.     {
    
53.         if( mempool == NULL )
    
54.         {
    
55.             free( p );
    
56.         }
    
57.         else
    
58.         {
    
59.             mempool->freeMemBuf( p );
    
60.         }
    
61.     };
    
62. 
    
63.     static Mempool<Test> *mempool;
    
64. 
    
65. #endif
    
66. 
    
67.     static int count1;
    
68.     static int count2;
    
69.     
    
70. 
    
71. private:
    
72.     int a;
    
73.     int b;
    
74.     char data[2048];
    
75. };
    
76. 
    
77. int Test::count1 = 0;
    
78. int Test::count2 = 0;
    
79. #ifdef _MEM_POOL_
    
80. Mempool<Test>* Test::mempool = NULL;
    
81. #endif
    
82. 
    
83. int main()
    
84. {
    
85. #ifdef _MEM_POOL_
    
86.     Test::mempool = new Mempool<Test>(5);
    
87. #endif
    
88. 
    
89.     clock_t start, end;
    
90.     double duration;
    
91. 
    
92.     start = clock();
    
93. 
    
94.     for(int i = 0 ; i < 10000000; ++i)
    
95.     {
    
96.         Test *t = new Test;
    
97.         //t->show();
    
98.         delete t;
    
99.     }
    
100. 
     
101.     //cout << "count1 = " << Test::count1 << " count2 = " << Test::count2 << endl;
     
102. 
     
103.     end = clock();
     
104. 
     
105.     duration = double(end - start) / CLOCKS_PER_SEC;
     
106. 
     
107.     cout << "total used " << duration << "s" << endl;
     
108. 
     
109.     system("pause");
     
110. 
     
111.     return 0;
     
112. 
     
113. }