【深度探索STL】空间配置器(一) 构造和析构

以STL运用的角度而言，空间配置器总是隐藏在一切组件的背后，但就STL 的实现角度而言，我们需要了解空间配置器，因为整个STL 的操作对象(所有数值，“value”语意)都存放在容器之内，而容器一定需要配置空间以置放数据。

一般而言，我们所习惯的C++ 内存配置操作和释放操作是这样的

class Foo { ... };
Foo* pObj = new Foo;
delete pObj;

其中new 运算包含两阶段操作：1. 调用 ::operator new 配置内存，2. 调用构造函数 Foo() 构造对象。 delete 运算也包含两个阶段：1. 调用析构函数 ~Foo() 将对象析构， 2. 调用 ::operator delete 释放内存。

STL 为了提高效率则把二者分开，对象的构造和析构由::construct() 和::destory() 完成，内存的配置则是由 std::alloc 完成。
先介绍构造和析构基本工具：construct() 和 destroy()        下载源码：http://www.sgi.com/tech/stl/download.html

/*from stl source code v3.3 http://www.sgi.com/tech/stl/download.html
part of <stl_construct.h>*/
//为了便于理清，这里针对源码进行了修改
#include <new.h>   //欲使用 placement new，需先包含此文件

//construct()
template <class _T1, class _T2>
inline void construct(_T1* __p, const _T2& __value) {
	new ((void*)__p) _T1(__value);           // placement new; 调用 _T1::_T1(__value),构造新对象到预分配的内存上
}

template <class _T1>
inline void construct(_T1* __p) {
	new ((void*)__p) _T1();
}

//destroy()
template <class _Tp>
inline void destroy(_Tp* __pointer) {
	__pointer->~_Tp();    //调用~_Tp()
}

placement new 允许你在一个已经分配好的内存中(栈或堆)构造一个新的对象，原型中 (void*) __p 实际上就是指向一个已经分配好的内存缓冲区的首地址。STL 借助C++中的 placement new 来提高效率，因为使用 new 操作符分配内存需要在堆中查找足够大的剩余空间，这个操作速度是很慢的，而且有可能出现无法分配内存的异常。借助 placement new 就可以解决这个问题，我们构造对象都是在一个预先准备好了的内存缓冲区中进行，不需要查找内存，内存分配的时间是常数，而且不会出现在程序运行中途出现内存不足的异常。

上面的析构函数是接受一个指针，STL 另外提供一个版本用来析构两个迭代器所指范围内的所有对象。

/*这里对比源码调整了顺序*/
template <class _ForwardIterator>
inline void destroy(_ForwardIterator __first, _ForwardIterator __last) {
	_Destroy(__first, __last);                        //调用_Destroy()
}

//函数内部调用的函数__destroy()多了个参数，__VALUE_TYPE(__first)，用于找出元素的数值型别
template <class _ForwardIterator>
inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
	__destroy(__first, __last, __VALUE_TYPE(__first));    //调用__destroy()
}

//判断元素的数值型别是否有无用的析构函数(trivial_destructor)
template <class _ForwardIterator, class _Tp>
inline void
__destroy(_ForwardIterator __first, _ForwardIterator __last, _Tp*)
{
	typedef typename __type_traits<_Tp>::has_trivial_destructor
		_Trivial_destructor;
	__destroy_aux(__first, __last, _Trivial_destructor());  //调用__destroy_aux()
}

//如果元素的数值型别具备的是有用的析构函数，那么函数内部调用destroy()
template <class _ForwardIterator>
void
__destroy_aux(_ForwardIterator __first, _ForwardIterator __last, __false_type)
{
	for (; __first != __last; ++__first)
		destroy(&*__first);    //调用destroy()
}

//如果元素的数值型别有无用的析构函数，函数体无操作
template <class _ForwardIterator>
inline void __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type) {}

//迭代器版本destroy() -> _Destroy() -> __destroy() -> __destroy_aux() -> destroy() 指针版本
//所以实际上是逐个析构，只是中间为了效率，引入了判断元素的数值型别，来确定对象是否具备有用的析构函数

上面可以看出，对于迭代器版本的destroy() 实际最后都落脚到了单一对象指针版本的 destroy()。那么为什么要绕一大圈呢？因为这里接受的参数是两个迭代器，目的就是将这两个迭代器范围内的所有对象都析构掉，如果范围很大，并且对象的析构函数都是无关紧要的，那么一次次的调用这些个无用的析构函数，势必会对效率产生大的影响，所以先利用__VALUE(__first) 获得迭代器所指对象的型别，再利用 __type_traits<_Tp> 判断该型别的析构函数是否无关痛痒，如果是则什么也不做，如果不是则循环逐个析构范围内的对象。

所以对象的构造实际是通过 placement new 完成的(缓存提前分配然后进行对象的分配)；对象的析构则通过调用外在的析构函数(~_Tp())。注意的是，这里的析构只是析构对象，分配好的缓存并没有释放，所以可以反复利用缓存并给它分配对象。不打算再次使用这个缓存时，你可以delete 将其释放掉。

另外destroy() 第二版本还针对迭代器类型为 char* 和 wchar_t* 定义了特化版本

inline void destroy(char*, char*) {}
inline void destroy(wchar_t*, wchar_t*) {}

下面插图来源于《STL 源码剖析》，有利于从全局把握destroy()。

后面将陆续学习STL 内存的配置和释放。