<b>C++内存管理改革(4): boost::object_pool</b>[VC/C++编程]

言归正传.我们在内存池(MemPool)技术详解已经介绍了boost::pool组件.从内存管理见解的改革来看,这是是一个传统的MemPool组件,固然也有一定的改良（但只是性能上的改良）.但boost::object_pool差别,它与我在C++内存管理改革夸大的见解非常符合.可以认为,boost::object_pool是一种不通用的gc allocator组件.

我已经多次提出gc allocator的概念.这里仍旧需求夸大一下,所谓gc allocator,是指具垃圾回收本领的allocator.C++内存管理改革(1)　中我们引入了这个概念,但是没有明确gc allocator一词.

boost: object_pool内存管理见解

boost::object_pool的了不起之处在于,这是C++从库的层次上头一次承认,程序员在内存管理上是会出错误的,由程序员来确保内存不泄露是艰难的.boost::object_pool答应你忘掉释放内存.我们来看一个例子:

class X　{　…　};

　　　　void　func()
　　　　{
　　　　　　　 boost::object_pool<X>　alloc;

　　　　　　　 X*　obj1　=　alloc.construct();
　　　　　　　　X*　obj2　=　alloc.construct();
　　　　　　　 alloc.destroy(obj2);
　　　　}

假如boost::object_pool只是一个普通的allocator,那么这段代码明显存在问题,因为obj1的析构函数没有履行,申请的内存也没有释放.

但是这段代码是完好正常的.是的,obj1的析构确切履行了,所申请内存也被释放了.这就是说,boost::object_pool既支持你手工释放内存（通过主动调用object_pool::destroy）,也支持内存的自动回收（通过object_pool::~object_pool析构的履行）.这正符合gc allocator的规格.

注:内存管理更好的说法是对象管理.内存的申请和释放更切当的说是对象的成立和销毁.但是这里我们不决心辨别这二者的差别.

boost: object_pool与AutoFreeAlloc

我们知道,AutoFreeAlloc不支持手工释放,而只能等到AutoFreeAlloc对象析构的时刻一次性全部释放内存.那么,能否可以认为boost::object_pool能否比AutoFreeAlloc越发完备呢?

其实不然.boost::object_pool与AutoFreeAlloc都不是完好意义上的gc allocator.AutoFreeAlloc因为它只能一次性释放,故此仅仅实用特定的用况.但是固然AutoFreeAlloc不是普适的,但它是通用型的gc allocator.而boost::object_pool只能管理一种对象,并非通用型的allocator,范围性其实更强.

boost: object_pool的实现细节

大家对boost::object_pool应当已经有了一个总体的掌控.目前,让我们深化到object_pool的实现细节中去.

在内存池(MemPool)技术详解中,我们介绍boost::pool组件时,特地提醒大家留神pool::ordered_malloc/ordered_free函数.事实上,boost::object_pool的malloc/construct, free/destroy函数调用了pool::ordered_malloc, ordered_free函数,而不是pool::malloc, free函数.

让我们注释下为什么.

其实这此中的关键,在于object_pool要支持手工释放内存和自动回收内存（并自动履行析构函数）两种情势.假如没有自动析构,那么普通的MemPool就充足了,也就不需求ordered_free.既然有自动回收,同时又存在手工释放,那么就需求区份内存块（MemBlock）中哪些结点（Node）是安闲内存结点（FreeNode）,哪些结点是已经利用的.关于哪些已经是安闲内存的结点,明显不能再调用对象的析构函数.

我们来看看object_pool::~object_pool函数的实现:

template　<typename　T,　typename　UserAllocator>
object_pool<T,　UserAllocator>::~object_pool()
{
　　//　handle　trivial　case
　　if　(!this->list.valid())
　　　　return;

　　details::PODptr<size_type>　iter　=　this->list;
　　details::PODptr<size_type>　next　=　iter;

　　//　Start　’freed_iter’　at　beginning　of　free　list
　　void　*　freed_iter　=　this->first;

　　const　size_type　partition_size　=　this->alloc_size();

　　do
　　{
　　　　//　increment　next
　　　　next　=　next.next();

　　　　//　delete　all　contained　objects　that　aren’t　freed

　　　　//　Iterate　’i'　through　all　chunks　in　the　memory　block
　　　　for　(char　*　i　=　iter.begin();　i　!=　iter.end();　i　+=　partition_size)
　　　　{
　　　　　　//　If　this　chunk　is　free
　　　　　　if　(i　==　freed_iter)
　　　　　　{
　　　　　　　　//　Increment　freed_iter　to　point　to　next　in　free　list
　　　　　　　　freed_iter　=　nextof(freed_iter);

　　　　　　　　//　Continue　searching　chunks　in　the　memory　block
　　　　　　　　continue;
　　　　　　}

　　　　　　//　This　chunk　is　not　free　(allocated),　so　call　its　destructor
　　　　　　static_cast<T　*>(static_cast<void　*>(i))->~T();
　　　　　　//　and　continue　searching　chunks　in　the　memory　block
　　　　}

　　　　//　free　storage
　　　　UserAllocator::free(iter.begin());

　　　　//　increment　iter
　　　　iter　=　next;
　　}　while　(iter.valid());

　　//　Make　the　block　list　empty　so　that　the　inherited　destructor　doesn’t　try　to
　　//　　free　it　again.
　　this->list.invalidate();
}

这段代码不难理解,object_pool遍历全部申请的内存块（MemBlock）,并遍历此中全部结点（Node）,假如该结点不呈目前安闲内存结点（FreeNode）的列表（FreeNodeList）中,那么,它就是用户未主动释放的结点,需求举行呼应的析构操作.

目前你懂得了,ordered_malloc是为了让MemBlockList中的MemBlock有序,ordered_free是为了让FreeNodeList中的全部FreeNode有序.而MemBlockList, FreeNodeList有序,是为了更快地检测Node是安闲的还是被利用的（这实际上是一个调集求交的流程,倡议你看看std::set_intersection,它定义在STL的<algorithm>中）.