一般而言，我们习惯C++内存申请操作和释放操作如下：
class Foo{};
Foo * pf = new Foo; //1.申请空间2.调用构造函数
delete pf; //1.析构函数2.释放空间
但是为了精确分工，STL Allocator这两个阶段分开来。PS：以下代码不讨论多线程情况
内存申请：alloc::allocate()负责。
内存释放：alloc::deallocate()负责。
对象构造：全局 ::construct()负责。
对象析构：全局 ::destroy()负责。
1.<stl_construct.h> 对象构造和析构关键代码
【::construct()和::destroy()被设计为全局函数。::destory()有2个版本，第一个版本接受一个指针，调用该析构函数即可，第二个版本考虑到大范围的对象析构可能无关痛痒(trivial destructor),使用value_type()获得迭代器所指对象的型别，再利用__tyep_traits<T>判断trivial？不做：调用第一个版本】
#include <new.h> //为了使用placement new template <class T1, class T2> inline void construct(T1* p, const T2& value) { new (p) T1(value); // placement new; 显示调用构造函数T1(value); } // 以下是destroy() 第一版本，接受一个对象指针。 template <class T> inline void destroy(T* pointer) { pointer->~T(); // 析构 } // 以下是destroy() 第二版本，接受两个迭代器，此函数找出元素得数值类型 // 利用__type_traits<> 采用适当措施 template <class ForwardIterator> inline void destroy(ForwardIterator first, ForwardIterator last) { __destroy(first, last, value_type(first)); } // 判断对象的value type是否有trivial destructor template <class ForwardIterator, class T> inline void __destroy(ForwardIterator first, ForwardIterator last, T*) { typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor; __destroy_aux(first, last, trivial_destructor()); } // 如果对象的型別（value type）有non-trivial(要紧的) destructor //循环调用destroy一个版本 template <class ForwardIterator> inline void __destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) { for ( ; first < last; ++first) destroy(&*first); } // 如果对象的型別（value type）有trivial(无关紧要的) destructor template <class ForwardIterator> inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) { //不处理 } // 以下是destroy() 第二版本針對迭代器為char* 和wchar_t* 的特化版 inline void destroy(char*, char*) {} inline void destroy(wchar_t*, wchar_t*) {}
2.<stl_alloc.h> 空间的申请和释放
【C++内存申请基本操作：::operator new(),内存释放基本操作：::operator delete()。SGI用malloc和free这2个C函数代替完成内存的申请和释放。考虑到内存碎片问题，SGI设计了两级配置器，第一级直接使用malloc和free，包括了内存不足处理机制，需要调用者自己提供。第二级判断配置区超过128字节，调用第一级配置器。小于128字节，采用内存池管理】
2.1 配置器接口
//简单的转调用，可能第一级或者第二级配置器
template<class T, class Alloc> class simple_alloc { public: static T *allocate(size_t n) { return 0 == n? 0 : (T*) Alloc::allocate(n * sizeof (T)); } static T *allocate(void) { return (T*) Alloc::allocate(sizeof (T)); } static void deallocate(T *p, size_t n) { if (0 != n) Alloc::deallocate(p, n * sizeof (T)); } static void deallocate(T *p) { Alloc::deallocate(p, sizeof (T)); } };
2.2 vector简单使用例子
template<class T, class Alloc> class vector { protected: typedef simple_alloc<value_type,Alloc> data_allocator; void deallocate() { if(...) data_allocator::deallocate(start,end_of_storage - start); } };
2.3 第一级配置器
【SGI第一级配置器的allocate和realloc都是在调用C函数malloc和realloc不成功后，改调用oom_malloc和oom_realloc，后两者都有内循环，不断调用你指定的内存不足处理函数】
// Malloc-based allocator. Typically slower than default alloc below. // Typically thread-safe and more storage efficient. #ifdef __STL_STATIC_TEMPLATE_MEMBER_BUG # ifdef __DECLARE_GLOBALS_HERE void (* __malloc_alloc_oom_handler)() = 0; // g++ 2.7.2 does not handle static template data members. # else extern void (* __malloc_alloc_oom_handler)(); # endif #endif //inst没排上用场 template <int inst> class __malloc_alloc_template { private: //处理内存不足 static void *oom_malloc(size_t); static void *oom_realloc(void *, size_t); #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG static void (* __malloc_alloc_oom_handler)(); #endif public: static void * allocate(size_t n) { //第一级直接用malloc; void *result = malloc(n); //malloc内存不足补救函数 if (0 == result) result = oom_malloc(n); return result; } static void deallocate(void *p, size_t /* n */) { //直接free free(p); } static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz) { //直接使用realloc 下面为补救函数 void * result = realloc(p, new_sz); if (0 == result) result = oom_realloc(p, new_sz); return result; } static void (* set_malloc_handler(void (*f)()))() { //指定你的out-of-memory处理函数 void (* old)() = __malloc_alloc_oom_handler; __malloc_alloc_oom_handler = f; return(old); } }; // malloc_alloc out-of-memory handling #ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG template <int inst> //你的out-of-memory处理函数初始为 void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0; #endif template <int inst> void * __malloc_alloc_template<inst>::oom_malloc(size_t n) { void (* my_malloc_handler)(); void *result; for (;;) { //不断尝试释放，申请，再释放，再申请 my_malloc_handler = __malloc_alloc_oom_handler; if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; } //调用你的处理函数企图释放内存 (*my_malloc_handler)(); //再一次申请 result = malloc(n); if (result) return(result); } } template <int inst> void * __malloc_alloc_template<inst>::oom_realloc(void *p, size_t n) { void (* my_malloc_handler)(); void *result; for (;;) { //同上 my_malloc_handler = __malloc_alloc_oom_handler; if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; } (*my_malloc_handler)(); result = realloc(p, n); if (result) return(result); } }
2.4 第二级配置器
【每次先申请一大块内存作为内存池，并且维护16条链表，分别从8-16-24-32……-128字节(配置器会主动将当前内存申请提升到8的倍数)，链表负责配置出去(配置出去时链表不再指向)和回收回来(回收回来时链表重新指向)，当链表空间不足时向内存池申请。】
2.4.1 链表节点结构
//利用union的性质使得链表既是指针又是实际区块 union obj { union obj * free_list_link; char client_data[1]; //柔性数组 };
2.4.2 配置器类内代码
enum {__ALIGN = 8}; enum {__MAX_BYTES = 128}; enum {__NFREELISTS = __MAX_BYTES/__ALIGN}; #endif template <bool threads, int inst> class __default_alloc_template { private: //扩展到__ALIGN的倍数也即是的倍数 static size_t ROUND_UP(size_t bytes) { return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1)); } private: union obj { union obj * free_list_link; char client_data[1]; /* The client sees this. */ }; private: //16条链表 static obj * free_list[__NFREELISTS]; //根据申请的大小快速找到所属链表 static size_t FREELIST_INDEX(size_t bytes) { return (((bytes) + __ALIGN-1)/__ALIGN - 1); } //向内存池申请n大小的区间n为的倍数 static void *refill(size_t n); //内存池成处理申请函数一般为一次性配置nobjs个size大小的块nobjs默认为 //不足时,nobjs返回不定数目 static char *chunk_alloc(size_t size, int &nobjs); //内存池起始位置只在chunk_alloc变化 static char *start_free; //内存池结束位置只在chunk_alloc变化 static char *end_free; //内存池heap_size static size_t heap_size; public: //申请 static void * allocate(size_t n); //回收 static void deallocate(void *p, size_t n); static void * reallocate(void *p, size_t old_sz, size_t new_sz); } ;
2.4.3 allocate()实现
/* n must be > 0 */ static void * allocate(size_t n) { obj * __VOLATILE * my_free_list; obj * __RESTRICT result; //大于字节就调用第一级配置器 if (n > (size_t) __MAX_BYTES) { return(malloc_alloc::allocate(n)); } //找到链表中的所属链表 my_free_list = free_list + FREELIST_INDEX(n); result = *my_free_list; //链表没有可用的块调用refill申请 if (result == 0) { void *r = refill(ROUND_UP(n)); return r; } //调整链表不再指向这块被使用的块 *my_free_list = result -> free_list_link; return (result); };
2.4.4 deallocate()实现
/* p may not be 0 */ static void deallocate(void *p, size_t n) { obj *q = (obj *)p; obj * __VOLATILE * my_free_list; //大于使用第一级配置器 if (n > (size_t) __MAX_BYTES) { malloc_alloc::deallocate(p, n); return; } //找到所属链表 my_free_list = free_list + FREELIST_INDEX(n); //调整链表回收区块 q -> free_list_link = *my_free_list; //链表重新指向回收块 *my_free_list = q; }
2.4.5 refill()实现
void* __default_alloc_template<threads, inst>::refill(size_t n) { //默认申请块数 int nobjs = 20; //nobjs为传引用 char * chunk = chunk_alloc(n, nobjs); obj * __VOLATILE * my_free_list; obj * result; obj * current_obj, * next_obj; int i; //只有一块返回给调用者链表无新节点 if (1 == nobjs) return(chunk); //不止一块找到所属链表 my_free_list = free_list + FREELIST_INDEX(n); //对新的区块建链表 result = (obj *)chunk; //链表指向从内存池拿出的链表 *my_free_list = next_obj = (obj *)(chunk + n); //将新链表之间的节点串接起来 for (i = 1; ; i++) //从开始第个返回给申请者 { //当前节点 current_obj = next_obj; //指向下一个节点 next_obj = (obj *)((char *)next_obj + n); if (nobjs - 1 == i) { //尾节点置 current_obj -> free_list_link = 0; break; } else { //当前节点指向下一个节点 current_obj -> free_list_link = next_obj; } } return(result); //返回给申请者 }
2.4.6 内存池chunk_alloc()实现
_default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs) { char * result; //申请总量 size_t total_bytes = size * nobjs; //内存池余额 size_t bytes_left = end_free - start_free; //余额满足申请总量 if (bytes_left >= total_bytes) { //返回result result = start_free; //内存池可用起始地址+=申请总量 start_free += total_bytes; return(result); } //不足以满足申请总量但是可以供应一个以上区块 else if (bytes_left >= size) { //重新得到能够供应个数 nobjs = bytes_left/size; //重新计算总量 total_bytes = size * nobjs; //同上 result = start_free; start_free += total_bytes; return(result); } //一个区块都提供不了 else { size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4); //余额大于把这些零头凑到链表里去 if (bytes_left > 0) { obj * __VOLATILE * my_free_list = free_list + FREELIST_INDEX(bytes_left); ((obj *)start_free) -> free_list_link = *my_free_list; *my_free_list = (obj *)start_free; } //申请heap空间，补充内存池 start_free = (char *)malloc(bytes_to_get); if (0 == start_free) { int i; obj * __VOLATILE * my_free_list, *p; // Try to make do with what we have. That can't // hurt. We do not try smaller requests, since that tends // to result in disaster on multi-process machines. //以下搜索适当的链表 //适当是指"尚有未用区块的链表" for (i = size; i <= __MAX_BYTES; i += __ALIGN) { //拿到这个链表 my_free_list = free_list + FREELIST_INDEX(i); p = *my_free_list; // if (0 != p) { //调整链表释放未使用区块 //链表起始指向下一个区块 *my_free_list = p -> free_list_link; //内存池开头指向这个区块 start_free = (char *)p; //结尾指向区块结尾 end_free = start_free + i; //再一次调用自身 return(chunk_alloc(size, nobjs)); // Any leftover piece will eventually make it to the // right free list. } } //没办法没内存用了 end_free = 0; // In case of exception. //调用第一级配置器看看out-of-memory机制能否出点力 start_free = (char *)malloc_alloc::allocate(bytes_to_get); // This should either throw an exception // or remedy the situation. Thus we assume it // succeeded. } //heap_size+= heap_size += bytes_to_get; //结束位置重新界定 end_free = start_free + bytes_to_get; return(chunk_alloc(size, nobjs)); } }