Boost库之pool的使用

Boost库的pool提供了一个内存池分配器，用于管理在一个独立的、大的分配空间里的动态内存分配。Boost库的pool主要适用于快速分配同样大小的内存块，尤其是反复分配和释放同样大小的内存块的情况。使用pool内存池主要有以下两个优点：
　　1. 能够有效地管理许多小型对象的分配和释放工作，避免了自己去管理内存而产生的内存碎片和效率低下问题。
　　2.  告别程序内存泄漏的烦恼，pool库会在内部对内存自动进行管理，避免了程序员一不小心而造成的内存泄漏问题。

      pool库主要提供了四种内存池接口，分别是pool、object_pool、singleton_pool和pool_allocator（fast_pool_allocator）。

pool接口：头文件为<boost/pool/pool.hpp>，主要用于快速分配小块内存，使用时需要指定每次要分配的内存块的大小。其malloc函数用于从内存池中分配内存；free函数用于释放内存，并交还给内存池，而不是系统；release_memory函数用于释放所有未被分配的内存；purge_memory函数用于释放所有内存。当然，也可以不调用free或release_memory等函数，pool接口对象在析构时会调用purge_memory自动释放所有内存。当然，也可以不调用free或release_memory等函数，pool接口对象在析构时会调用purge_memory自动释放所有内存。示例代码如下：

 pool <>   myPool( sizeof ( int ));
2      for  ( int  i  =   0 ; i  <   10 ; i ++ )
3      {
4        int *pnNum = (int *)myPool.malloc();
5        *pnNum = i+1;
6        cout << *pnNum << endl;
7    }

object_pool接口：头文件为<boost/pool/object_pool.hpp>，顾名思义，主要用于对象的内存分配并自动调用类的构造函数。其construct函数用于从内存池中分配内存并自动调用构造函数，其destroy函数用于释放内存交还给内存池并自动调用析构函数。与pool接口一样，也可以不调用destroy函数，object_pool接口对象在析构时会自动释放所有内存并自动调用析构函数。另外，object_pool接口也有malloc和free函数，但其malloc只分配内存而不负责构造，free只释放内存而不负责析构。因此，最好将construct和destroy配对使用，将malloc和free配对使用，而不要两者混用。示例代码如下：

1         object_pool<CTest>  myObjectPool;
2         for (int j = 0; j < 10; j++)
3         {
4             CTest *pTest = (CTest *)myObjectPool.construct(j*j);
5             if (j == 5)
6             {
7                 myObjectPool.destroy(pTest);
8             }
9         }

singleton_pool接口：头文件为<boost/pool/singleton_pool.hpp>，singleton_pool接口的构造函数是私有的，因此不能够创建一个singleton_pool接口的对象。singleton_pool接口提供了一些静态方法如malloc、free用于内存的分配和释放，其他方面与pool接口相同。示例代码如下：

 1 struct intpool { };
 2 struct intpool2 { };
 3 typedef singleton_pool<intpool, sizeof(int)> ipool1;
 4 typedef singleton_pool<intpool2, sizeof(int)> ipool2;
 5     for (int i = 0; i < 10; ++i)
 6      {
 7          int *q1 = (int *)ipool1::malloc();
 8          int *q2 = (int *)ipool2::malloc();
 9         *q1 = i;
10         *q2 = i*i;
11         cout << *q1 << " and " << *q2 << endl;
12      }
13      ipool1::purge_memory();
14      ipool2::purge_memory();

pool_allocator接口：头文件为<boost/pool/pool_allocator.hpp>，主要与STL的容器一起使用，可用于代替STL中的allocator。示例代码如下：

1    vector<int, pool_allocator<int> >  vctTemp;
2    list<char, fast_pool_allocator<char> >  lstTemp;

中，pool_allocator的内部实现调用了ordered_malloc和ordered_free，可以满足对大量的连续内存块的分配请求。fast_pool_allocator 的内部实现调用了malloc和free，比较适合于一次请求单个大内存块的情况，但也适用于通用分配，不过具有一些性能上的缺点。

• pool 接口需要知道每个单独的元素而不是类型的大小，因为它是一个 malloc 风格的分配程序，不会调用构造函数。
• pool 接口中的 malloc 例程返回 void*。
• object-pool 接口需要类型信息，因为要调用构造函数。
• object-pool 接口中的 malloc/construct 例程返回指向类型的指针。malloc 例程不调用构造函数，但是 construct 要调用构造函数。
• 使用 pool 接口或 object-pool 接口来创建的元素的范围与从中创建它们的池的范围相同。
• 要从池接口中释放内存，可以调用 purge_memory 方法。该方法释放您先前创建的内存块，并使得从分配程序例程返回的所有指针失效。
• 要释放各个元素，可以调用 pool 接口中的 free 例程。例如，如果 t 是使用 pool 接口来创建的池，并且 m 是从 t 分配的指针，则 t.free(m) 将把内存返回给 t（将其添加到 t 的空闲内存列表）。
  

#include <iostream>
#include <boost/pool/pool.hpp>
#include <boost/pool/object_pool.hpp>
using namespace std;
using namespace boost;

class A
  {
  public: A( ) { cout << "Declaring A\n"; }
         ~A( ) { cout << "Deleting A\n"; }
  };

int main ( )
  {
  cout << "Init pool...\n";

  pool<> p(10 * sizeof(A));
  for (int i=0; i<10; ++i)
    A* a = (A*) p.malloc(); // Always returns sizeof(A)
  p.purge_memory();

  cout << "Init object pool...\n";

  object_pool<A> q;
  for (int i=0; i<10; ++i)
    A* a = q.construct(); // Calls A's constructor 10 times

  return 0;
  }

singleton_pool 接口——与 pool 接口几乎相同，但是用作独立池。独立池的底层结构具有为 malloc、free 等声明的静态成员函数，并且构造函数是私有的。独立池声明中的第一个参数称为标记——它允许存在不同的独立池集（例如，用于 int 的多个池，其中每个池服务于不同的目的）。必须包括 singleton_pool.hpp 头文件才能使用此接口。请参见清单 14。

                        
#include <iostream>
#include <boost/pool/singleton_pool.hpp>
using namespace std;
using namespace boost;

struct intpool {  };
struct intpool2 {  };

typedef boost::singleton_pool<intpool, sizeof(int)> ipool1;
typedef boost::singleton_pool<intpool2, sizeof(int)> ipool2;

int main ( )
  {
  cout << "Init singleton pool...\n";
  for (int i=0; i<10; ++i) {
    int* q1 = (int*) ipool1::malloc();
    int* q2 = (int*) ipool2::malloc();
  }

  ipool1::purge_memory();
  ipool2::purge_memory();
  return 0;
  }