boost之内存池

pool

pool是最简单也最容易使用的内存池类，可以返回一个简单数据类型(（POD)R的内存指针。它位于名字空间boost，需要包含头文件<boost/pool/pool.hpp>，即:

#include <boost/pool/pool.hpp>

using namespace boost;

template<typename UserAllocator=default_user_allocator_new_delete>
class pool
{
    public:
    explicit pool(size_type requested_size);
    ~pool();
    size_type get_requested_size() const;//分配内存块大小
    void*  malloc();
    void*  ordered_malloc();
    void*  ordered_malloc(size_type n);
    bool   is_from(void* chunk) const;
    ....
}

pool的模板类型参数UserAllocator是一个用户定义的内存分配器，它实现了特定的内存分配算法，通常可以直接用默认的default_user_allocator_new_delete，它内部使用new [ ]和 delete[]分配内存。

pool的构造函数接受一个size_type类型的整数requested_size,指示每次分配内存块的大小(而不是内存池的大小)，这个值可以用get_requested_size ()获得。pool 会根据需要自动地向系统申请或归还使用的内存，在析构时，pool将自动释放它所持有的所有内存。

成员函数malloc ()和 ordered_malloc()的行为很类似c中的全局函数malloc( ) ，用void*指针返回从内存池中分配的内存块，大小为构造函数中指定的requested_size。如果内存分配失败，函数会返回p(即空指针)，不会抛出异常。malloc( )从内存池中任意分配一个内存块，而 ordered_malloc ()则在分配的同时合并空闲块链表。ordered_malloc ()带参数的形式还可以连续分配n 块的内存。分配后的内存块可以用is_from()函数测试是否是从这个内存池分配出去的。

最后还有两个成员函数: release_memory ()让内存池释放所有未被分配的内存，但已分配的内存块不受影响; purge_memory ()则强制释放 pool持有的所有内存，不管内存块是否被使用。实际上，pool的析构函数就是调用的 purge_memory()。这两个函数一般情况下也不应该由程序员手工调用。

实例：

#include<boost/pool/pool.hpp>
#include<iostream>
using namespace boost;
int main()
{
    pool<>p1(sizeof(int));//可分配int的pool
    int* p=static_cast<int*>(p1.malloc());
    if(p!=nullptr)
    {
        std::cout<<"yes"<<std::endl;
    }
    p1.free(p);
    for(int i=0;i<100;i++)
    {
        p1.ordered_malloc(10);
    }
}

object_pool

object_pool是用于类实例（对象）的内存池，它的功能与pool类似，但会在析构时对所有已经分配的内存块调用析构函数，从而正确地释放资源。

object_pool位于名字空间boost，需要包含头文件<boost/pool/object_pool.hpp>，即:

#include <boost/pool / object_pool.hpp>

using namespace boost;

类摘要：

template<typename T,typename UserAllocator>
class object_pool: protected poll<UserAllocator>
{
 public:
 using Element_type=T;
 public:
 object_pool();
 ~object_pool();

 Element_type* malloc();
 void          free(Element_type* p);
 bool          is_from(Element_type* p)const;

 Element_type construct();
 void destroy(Element_type* p);
};

object pool是pool的子类，但它使用的是保护继承，因此不能使用pool的接口,但基本操作还是很相似的

object pool的模板类型参数T指定了object_pool要分配的元素类型,要求其析械函数不能抛出异常。一旦在模板中指定了类型，object_pool实例就不能再用于分配其他类型的对象。

object_pool 的特殊之处是 construct ()和 destroy()函数，这两个函数是object_pool 的真正价值所在。

construct()实际上是一组函数，有多个参数的重载形式(目前最多支持3个参数，但可以扩展)，它先调用malloc()分配内存，然后再在内存块上使用传入的参数调用类的构造函数，返回的是一个已经初始化的对象指针。destory()则先调用对象的析构函数，然后再用free ()释放内存块。

编译时要加外库 -lboost_system;

#include<boost/pool/object_pool.hpp>
#include<iostream>
#include<string>
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>p1;
    auto p=p1.malloc();
    assert(p1.is_from(p));
    
    p=p1.construct(6,7,8);
    assert(p->a==6);

    object_pool<std::string>pls;
    for(int i=0;i<10;i++)
    {
        std::string *ps=pls.construct("hello object_pool");
        std::cout<<*ps<<std::endl;
    }


}
//
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool
hello object_pool

更多的构建参数：

默认情况下，在使用object _pool的construct ()的时候我们只能最多使用3个参数来创建对象。大多数情况下这都是足够的，但有的时候我们可能会定义3个以上参数的构造函数，此时construct ()的默认重载形式就不能用了。

很遗憾，construct()并没有及时跟进c++标准使用可变参数模板支持任意数量的参数构造。它基于宏预处理m4(通常UNIX系统自带，也有 windows的版本）实现了一个变通的扩展机制，可以生成接受任意数量参数的construct ()函数代码。

pool库在目录/boost/pool/detail下提供了一个名为 pool_construct.m4 和pool_construct_simple.m4的脚本，并同时提供可在UNIX和 windows下运行的同名sh和 bat可执行脚本文件。只需要简单地向批处理脚本传递一个整数的参数N，m4就会自动生成能够创建具有N个参数的construct ()函数源代码。

./ pool_construct_simple.sh 5; ./pool_construct.sh 5

m4的解决方案显得比较笨拙，使用可变参数模板特性，我们可以定义一个辅助模板函数，支持任意数量的参数，彻底解决这个问题:

template<typename p,typename ... Args>
inline typename P::element_type*
construct(P&p,Args&&... args)
{
    using P::element_type* mem=p.malloc();
    assert(mem!=0);
    new(mem) typename P::element_type(
        std::forward<Args>(args)...
    );
    return mem;
};

自由函数construct()接受任意多个参数，第一个是object_pool对象，其后是创建对象所需参数，要创建的对象类型可以使用object_pool的内部类型定义element_type来获得。函数中首先调用malloc()分配一块内存，然后调用不太常见的“定位new表达式”(placement new expression）创建对象。

singleton_pool

singleton_pool 与 pool 的接口完全一致，可以分配简单数据类型（POD）的内存指针，但它是一个单件。

singleton_pool位于名字空间boost,需要包含头文件<boost/pool/singleton,pool.hpp>，即;

#include <boost/pool/singleton_pooi .hpp>

using namespace boost;

singleton_pool默认使用boost.thread库提供线程安全保证，所以需要链接boost_thread库，

如果不使用多线程，那么可以在头文件前定义宏BO0ST_POOL_NO_MT。

类摘要：

template<typename Tag,unsigned RequestedSize>
class singleton_pool
{
    public:
    static bool        is_from(void* ptr);
    void*  malloc();
    void*  ordered_malloc();
    void*  ordered_malloc(size_type n);
    ...
}

singleton_pool主要有两个模板类型参数（其余的可以使用默认值)。第一个Tag仅仅是用于标记不同的单件，可以是空类，甚至只是声明。第二个参数 RequestedSize等同于pool构造函数中的整数requested_size，指示pool分配内存块的大小。

singleton_pool的接口与pool完全一致，但成员函数均是静态的，所以不需要声明singleton_pool的实例，直接用域操作符“::”来调用静态成员函数。因为singleton_pool是单件，所以它的生命周期与整个程序同样长，除非手动调用release_memory()或purge_memory()，否则singleton_pool 不会自动释放所占用的内存。除了这两点，singleton pool的用法与pool完全相同。

用法：

#include<boost/pool/singleton_pool.hpp>
#define BOOST_POLL_NO_MT
using namespace boost;
#include<assert.h>

struct pool_tag{};
using sql=singleton_pool<pool_tag,sizeof(int)>;
int main()
{
    int *p=(int*)sql::malloc();
    assert(sql::is_from(p));
    sql::release_memory();
}