object_pool

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

object_pool位于名字空间boost，为了使用object_pool组件，需要包含头文件<boost/pool/object_pool .hpp>，即：

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

类摘要

template <typename T, typename UserAllocator>
class object_pool : protected pool<UserAllocator>
{
public:
   typedef T element_type;
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实例就不能再用于分配其他类型的对象。

malloc()和 free()函数分别分配和释放一块类型为T*的内存块，同样，可以用is_from()来测试内存块的归属，只有是本内存池分配的内存才能被free()释放。但它们被调用时并不调用类的构造函数和析构函数，也就是说，操作的是一块原始内存块，里面的值是未定义的，因此我们应当尽量少使用malloc()和 free()。

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

这些函数都不会抛出异常，如果内存分配失败，将返回0。

用法

object_pool的用法也很简单，我们既可以像pool那样分配原始内存块，也可以使用construct()来直接在内存池中创建对象。当然，后一种使用方法是最方便的。

#include <boost/pool/object_pool.hpp>

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; //对象内存池

	auto p = pl.malloc(); //分配一个原始内存块
	assert(pl.is_from(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; //定义一个分配string对象的内存池
	for (int i = 0; i < 10; ++i) //连续分配大量string对象
	{
		string* ps = pls.construct("hello object_pool");
		cout << *ps << endl;
	}
} //所有创建的对象在这里都被正确析构、释放内存

使用更多的构造参数

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

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

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

例如，在 Linux 下，执行命令：

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

将生成两个同名的.ipp文件，里面包含了新的construct()函数定义，能够支持最多传递5个参数创建对象。

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

template<typename P, typename ... Args> //C++11可变参数模板
inline typename P::element_type*
construct(P& p, Args&& ... args)
{
	typename P::element_type* mem = p.malloc();
	assert(mem != 0);
	new (mem) typename P::element_type(
		std::forward<Args>(args)...); //C++11的完美转发
	return mem;
}

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

假设我们有如下的一个4参数构造函数的类：

struct demo_class
{
	demo_class2(int, int, int, int) //构造函数接受4个参数
	{
		cout << "demo_class ctor" << endl;
	}
	~demo_class2()
	{
		cout << "demo_class dtor" << endl;
	}
};

那么使用自定义的construct()创建对象的代码就是：

object_pool<demo_class> p1;
auto d = construct(p1,1,2,3,4);

代码示例

#include <iostream>
using namespace std;

#include <boost/core/ignore_unused.hpp>

//#define BOOST_SYSTEM_NO_DEPRECATED
//#define BOOST_POOL_NO_MT
#include <boost/pool/pool.hpp>
using namespace boost;

#include <boost/pool/object_pool.hpp>

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) {}
};

void case2()
{
	object_pool<demo_class> pl;

	auto p = pl.malloc();
	assert(pl.is_from(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_pool");
		cout << *ps << endl;
	}
}

//

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

struct demo_class2
{
	demo_class2(int, int, int, int)
	{
		cout << "demo_class ctor" << endl;
	}
	~demo_class2()
	{
		cout << "demo_class dtor" << endl;
	}
};

void case3()
{
	object_pool<demo_class2> pl;
	auto d = construct(pl, 1, 2, 3, 4);

	boost::ignore_unused(d);
}

int main()
{
	case2();
	case3();
}