出差的这段时间想再次好好地学习了一下STL。接下来的几篇博文就自己阅读STL源码的一些个人理解分享，希望跟同行多多交流，有欠佳的地方还望各位多多指教。
STL中诸多容器和算法都要涉及到向系统申请和释放内存，所以先读读C++的内存管理----C++称其为allocator
1, default allocator
SGI STL 的头文件defalloc.h中有一个符合标准的名为allocator的内存分配器，它只是简单地将::operator new 和::operator delete做了一层薄薄的封装。在SGI STL的容器和算法部分从来没有用到这个内存分配器。在此略过。
2， STL 的内存分配策略
首先简要介绍一下STL中对内存分配的规划
当用户用new构造一个对象的时候，其实内含两种操作：1）调用::operator new申请内存；2）调用该对象的构造函数构造此对象的内容
当用户用delete销毁一个对象时，其实内含两种操作：1）调用该对象的析构函数析构该对象的内容；2）调用::operator delete释放内存
SGI STL中对象的构造和析构由::construct()和::destroy()负责；内存的申请和释放由alloc:allocate()和alloc:deallocate()负责；此外，SGI STL还提供了一些全局函数，用来对大块内存数据进行操作。
上一段提到的三大模块分别由stl_construct.h stl_alloc.h stl_uninitialized.h 负责
下面的各小节分别分析这三大模块的主要内容
3， 对象的构造和析构工具(stl_construct.h)
stl_construct.h中提供了两种对象的构造方法，默认构造和赋值构造：
1 template <class _T1, class _T2>
2 inline void _Construct(_T1* __p, const _T2& __value) {
3 new ((void*) __p) _T1(__value);
4 }
5
6 template <class _T1>
7 inline void _Construct(_T1* __p) {
8 new ((void*) __p) _T1();
9 }
上面两个函数的作用是构造一个类型为T1的对象，并由作为参数的指针p返回。
其中的new (_p) _T1(_value); 中使用了placement new算子，它的作用是通过拷贝的方式在内存地址_p处构造一个_T1对象。（placement new能实现在指定的内存地址上用指定类型的构造函数来构造一个对象）。
在对象的销毁方面，stl_construct.h也提供了两种析构方法：
1 template <class _Tp>
2 inline void _Destroy(_Tp* __pointer) {
3 __pointer->~_Tp();
4 }
5
6 template <class _ForwardIterator>
7 inline void _Destroy(_ForwardIterator __first, _ForwardIterator __last) {
8 __destroy(__first, __last, __VALUE_TYPE(__first));
9 }
第一个版本的析构函数接受一个指针，将该指针所指的对象析构掉；第二个版本的析构函数接受first和last两个迭代器，将这两个迭代器范围内的对象析构掉。
在第二个版本的destroy函数里面，运用了STL中惯用的traits技法，traits会得到当前对象的一些特性，再根据特性的不同分别对不同特性的对象调用相应的方法。在stl_construct.h中的destroy中，STL会分析迭代器所指对象的has_trivial_destructor特性的类型（只有两种：true_type和false_type），如果是true_type，STL就什么都不做；如果是false_type，就会调用每个对象的析构函数来销毁这组对象。
除此之外，stl_construct还为一些基本类型的对象提供了特化版本的destroy函数，这些基本类型分别是char, int, float, double, long。当destroy的参数为这些基本类型时，destroy什么都不做。
4，内存空间管理工具alloc
我想以自底向下的顺序介绍一下STL的allocator。首先说说STL内建的两种分配器，然后介绍STL如何封装这两种分配器对外提供统一的接口，最后用一个vector的例子看看容器如何使用这个allocator。
4.1 两种内存分配器
4.1.1 __malloc_alloc_template分配器
该分配器是对malloc、realloc以及free的封装：
1 static void* allocate(size_t __n)
2 {
3 void* __result = malloc(__n);
4 if (0 == __result) __result = _S_oom_malloc(__n);
5 return __result;
6 }
7
8 static void deallocate(void* __p, size_t /* __n */)
9 {
10 free(__p);
11 }
12
13 static void* reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
14 {
15 void* __result = realloc(__p, __new_sz);
16 if (0 == __result) __result = _S_oom_realloc(__p, __new_sz);
17 return __result;
18 }
当调用malloc和realloc申请不到内存空间的时候，会改调用oom_malloc()和oom_realloc()，这两个函数会反复调用用户传递过来的out of memory handler处理函数，直到能用malloc或者realloc申请到内存为止。如果用户没有传递__malloc_alloc_oom_handler，__malloc_alloc_template会抛出__THROW_BAD_ALLOC异常。
所以，内存不足的处理任务就交给类客户去完成。
4.1.2 __default_alloc_template分配器
这个分配器采用了内存池的思想，有效地避免了内碎片的问题（顺便一句话介绍一下内碎片和外碎片：内碎片是已被分配出去但是用不到的内存空间，外碎片是由于大小太小而无法分配出去的空闲块）。
如果申请的内存块大于128bytes，就将申请的操作移交__malloc_alloc_template分配器去处理；如果申请的区块大小小于128bytes时，就从本分配器维护的内存池中分配内存。
分配器用空闲链表的方式维护内存池中的空闲空间，空闲链表大概类似于下面的形状：
如图所示，s_free_list是这些空闲分区链的起始地址组成的数组，大小为16。这16个链表中每个链表中的空闲空间的大小都是固定的，第一个链表的空闲块大小是8bytes, 依次是16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128bytes。
另外还有三个指针s_start_free, s_end_free, s_heap_size。它们分别指向整个内存池的起始地址，结束地址和可用空间大小。
分配内存过程：
1）如果申请的内存空间大于128bytes, 则交由第一个分配器处理
2）分配器首先将申请内存的大小上调至8的倍数n，并根据n找出其对应的空闲链表地址__my_free_list
3）如果该空闲链表中有可用的空闲块，则将此空闲块返回并更新__my_free_list，否则转到4）
4）到这一步，说明__my_free_list中没有空闲块可用了，分配器会按照下面的步骤处理：
a) 试着调用_s_chunk_alloc()申请大小为n*20的内存空间，注意的是，此时不一定能申请到n*20大小的内存空间
b) 如果只申请到大小为n的内存空间，则返回给用户，否则到c)
c) 将申请到的n*x(a中说了，不一定是n*20)内存块取出一个返回给用户，其余的内存块链到空闲链表__my_free_list中
_s_chunk_alloc()的具体过程为：
1)如果_s_start_free和_s_end_free之间的空间足够分配n*20大小的内存空间，则从这个空间中取出n*20大小的内存空间，更新_s_start_free并返回申请到的内存空间的起始地址，否则转到2)
2) 如果_s_start_free和_s_end_free之间的空间足够分配大于n的内存空间，则分配整数倍于n的内存空间，更新_s_start_free，由nobj返回这个整数，并返回申请到的内存空间的起始地址；否则转到3）
3) 到这一步，说明内存池中连一块大小为n的内存都没有了，此时如果内存池中还有一些内存（这些内存大小肯定小于n），则将这些内存插入到其对应大小的空闲分区链中
4) 调用malloc向运行时库申请大小为（2*n*20 + 附加量）的内存空间， 如果申请成功，更新_s_start_free, _s_end_free和_s_heap_size，并重新调用_s_chunk_alloc()，否则转到5)
5) 到这一步，说明4)中调用malloc失败，这时分配器依次遍历16个空闲分区链，只要有一个空闲链，就释放该链中的一个节点，重新调用_s_chunk_alloc()
内存释放过程：
内存的释放过程比较简单，它接受两个参数，一个是指向要释放的内存块的指针p，另外一个表示要释放的内存块的大小n。分配器首先判断n，如果n>128bytes，则交由第一个分配器去处理；否则将该内存块加到相应的空闲链表中。
4.2 对外提供的分配器接口
SGI STL 为了方便用户访问，为上面提到的两种分配器包装了一个接口，该接口如下：
1 template<class _Tp, class _Alloc>
2 class simple_alloc {
3
4 public:
5 static _Tp* allocate(size_t __n)
6 { return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); }
7 static _Tp* allocate(void)
8 { return (_Tp*) _Alloc::allocate(sizeof (_Tp)); }
9 static void deallocate(_Tp* __p, size_t __n)
10 { if (0 != __n) _Alloc::deallocate(__p, __n * sizeof (_Tp)); }
11 static void deallocate(_Tp* __p)
12 { _Alloc::deallocate(__p, sizeof (_Tp)); }
13 };
用户调用分配器的时候，为simple_alloc的第二个模板参数传递要使用的分配器。
4.3 用户使用分配器的方式
下面是vector使用STL分配器的代码
1 template <class _Tp, class _Alloc>
//cobbliu 注：STL vector 的基类
2 class _Vector_base {
3 public:
4 typedef _Alloc allocator_type;
5 allocator_type get_allocator() const { return allocator_type(); }
6
7 _Vector_base(const _Alloc&)
8 : _M_start(0), _M_finish(0), _M_end_of_storage(0) {}
9 _Vector_base(size_t __n, const _Alloc&)
10 : _M_start(0), _M_finish(0), _M_end_of_storage(0)
11 {
12 _M_start = _M_allocate(__n);
13 _M_finish = _M_start;
14 _M_end_of_storage = _M_start + __n;
15 }
16
17 ~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
18
19 protected:
20 _Tp* _M_start;
21 _Tp* _M_finish;
22 _Tp* _M_end_of_storage;
23
24 typedef simple_alloc<_Tp, _Alloc> _M_data_allocator;
25 _Tp* _M_allocate(size_t __n)
26 { return _M_data_allocator::allocate(__n); }
27 void _M_deallocate(_Tp* __p, size_t __n)
28 { _M_data_allocator::deallocate(__p, __n); }
29 };
我们可以看到vector的基类调用simple_alloc作为其分配器
5，基本内存处理工具
除了上面的内存分配器之外，STL还提供了三类内存处理工具：uninitialized_copy(), uninitialized_fill()和uninitialized_fill_n()。这三类函数的实现代码在头文件stl_uninitialized.h中。
uninitialized_copy()像下面的样子：
1 template <class _InputIter, class _ForwardIter>
2 inline _ForwardIter
3 uninitialized_copy(_InputIter __first, _InputIter __last,
4 _ForwardIter __result)
5 {
6 return __uninitialized_copy(__first, __last, __result,
7 __VALUE_TYPE(__result));
8 }
uninitialized_copy()会将迭代器_first和_last之间的对象拷贝到迭代器_result开始的地方。它调用的__uninitialized_copy(__first, __last, __result,__VALUE_TYPE(__result))会判断迭代器_result所指的对象是否是POD类型（POD类型是指拥有constructor, deconstructor, copy, assignment函数的类），如果是POD类型，则调用算法库的copy实现；否则遍历迭代器_first~_last之间的元素，在_result起始地址处一一构造新的元素。
uninitialized_fill()像下面的样子：
1 template <class _ForwardIter, class _Tp>
2 inline void uninitialized_fill(_ForwardIter __first,
3 _ForwardIter __last,
4 const _Tp& __x)
5 {
6 __uninitialized_fill(__first, __last, __x, __VALUE_TYPE(__first));
7 }
uninitialized_fill()会将迭代器_first和_last范围内的所有元素初始化为x。它调用的__uninitialized_fill(__first, __last, __x, __VALUE_TYPE(__first))会判断迭代器_first所指的对象是否是POD类型的，如果是POD类型，则调用算法库的fill实现；否则一一构造。
uninitialized_fill_n()像下面这个样子：
1 template <class _ForwardIter, class _Size, class _Tp>
2 inline _ForwardIter
3 uninitialized_fill_n(_ForwardIter __first, _Size __n, const _Tp& __x)
4 {
5 return __uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first));
6 }
uninitialized_fill_n()会将迭代器_first开始处的n个元素初始化为x。它调用的__uninitialized_fill_n(__first, __n, __x, __VALUE_TYPE(__first))会判断迭代器_first所指对象是否是POD类型，如果是，则调用算法库的fill_n实现；否则一一构造。
6，总结
STL的内存分配和迭代器是理解一切容器实现细节的基础，本文主要粗略地介绍了一下STL中两种内存分配器的分配机制，没有涉及很多alloc_traits的内容，关于这部分的内容会在迭代器部分详细介绍。
7，参考文献
1）《STL源码剖析》第二章：空间配置器
2）sgi-stl-3.3 源代码
声明：本文系作者原创，如转载请注明出处http://www.cnblogs.com/cobbliu/archive/2012/04/05/2431804.html