boost pool库

一. pool库 -> pool P100

• 返回一个简单数据类型（POD）的内存指针，如int、double等.

      #include <boost/pool/pool.hpp>
      using namespace boost;
      int main()
      {
              pool<> pl(sizeof(int));    //一个可分配int的内存池
  
              int *p = (int*)pl.malloc();   //必须把void*转换成需要的类型
              assert(pl.is_from(p));
  
              pl.free(p);
              for(int i=0; i<100;i++)     //连续分配大量的内存
              {
                      pl.ordered_malloc(10);
              }
              return 0;
      }

二. pool库 -> object_pool P103

• 用于类实例（对象）的内存池，要求对象析构函数不能抛出异常

• object_pool construct()和destroy()函数，建议使用这两个函数

      #include "stdafx.h"
      #include <iostream>
      #include <string>
      #include <boost/pool/object_pool.hpp>
  
      using namespace std;
      using namespace boost;
  
      struct demo_class
      {
      public:
          int a, b, c;
          demo_class( int x = 1, int y = 2, int z = 3 )
              :a( x ), b( y ), c( z )
          {
          }
      };
  
      int main()
      {
          object_pool<demo_class> pl;
          demo_class *p = pl.malloc();
          assert( pl.is_from( p ) );
  
          //p指向的内存未经过初始化
          assert( p->a != 1 || p->b != 2 || p->c != 3 );
          p = pl.construct( 7, 8, 9 );
          assert( p->a == 7 );
          object_pool<string> pls;
          for (int i=0;i<10;++i)
          {
              string *ps = pls.construct( "hello object_poos" );
              cout << *ps << endl;
          }
  
          system( "PAUSE" );
          return 0;
      }

• 自定义参数个数

      #include <iostream>
      #include <string>
      #include <boost/pool/object_pool.hpp>
  
      using namespace std;
      using namespace boost;
  
      template <typename P, typename T0, typename T1, typename T2, typename T3>
      inline typename P::element_type* construct( P& p, const T0 & a0, const T1 & a1, const T2 & a2, const T3& a3 )
      {
          typename P::element_type* mem = p.malloc();
          assert( mem != NULL );
          new ( mem )P::element_type( a0, a1, a2, a3 );
          return mem;
      }
  
      struct demo_class
      {
      public:
          int a, b, c,d;
          demo_class( int x = 1, int y = 2, int z = 3,int u=4 )
              :a( x ), b( y ), c( z ), d(u)
          {
          }
          void show()
          {
              cout << "a=" << a << " b=" << b << " c=" << c << " d=" << d << endl;
          }
      };
  
      int main()
      {
          object_pool<demo_class> pl;
          //demo_class *p = pl.malloc();
          //assert( pl.is_from( p ) );
  
          //p指向的内存未经过初始化
          object_pool<demo_class> opl;
          demo_class* p = construct<object_pool<demo_class>, int, int, int, int>( opl, 1, 2, 3, 4 );
          int a = p->a;
          p->show();
  
          system( "PAUSE" );
          return 0;
      }

三. pool库 -> singleton_pool

• singleton_pool与pool的接口完全一样可以分配简单数据类型（POD）的内存指针，但它是一个单件，并提供线程安全。

• 成员函数为静态为单件，因此生命周期与整个程序同样长，除非手动调用release_memory()或purge_memory()，否则不会自动释放所占用的内存。

      #include <boost/pool/singleton_pool.hpp>
  
      using namespace std;
      using namespace boost;
  
      struct pool_tag{};
      typedef singleton_pool<pool_tag, sizeof( int )>spl;
  
      int main()
      {
          int *p = ( int * )spl::malloc();
          assert( spl::is_from( p ) );
          spl::release_memory();
          system( "PAUSE" );
          return 0;
      }