vector、list、map等容器在使用时常常涉及空间的管理，虽然这些空间都可以通过malloc或new直接申请，但仍以下不足之处：
- 空间申请与释放需要用户自己管理，容易造成内存泄漏。
- 如果频繁向系统申请小块内存，容易造成内存碎片，影响程序运行效率。
- 通过malloc或new直接申请，在每块空间分配前会有额外的空间开销；
- 需要为空间申请失败的情况定制应对方案。
对于"频繁向系统申请小块内存造成的"，C++标准库中的空间配置器提供了更优质的方案，可以支持各个容器提供高效的空间管理（空间的申请与回收），提升程序运行的效率。
空间配置器是STL的六大组件之一，以128作为小块内存与大块内存的分界线，将其分为两级结构，一级空间适配器处理大块内存，二级空间适配器处理小块内存。
其中最重要的就是通过allocate()以开辟空间，和通过deallocate()以释放空间，它们被运用在许多容器中。
本篇博客整理空间配置器的相关知识和部分实现代码，旨在让读者更好地理解STL的设计和功能。
目录
[2-3. 填充内存块](#2-3. 填充内存块)
一、一级空间配置器
一级空间配置器原理较为简单，对malloc与free进行了封装，间接去使用malloc开辟空间、free释放空间，专门处理大块内存。
cpp
//一级空间配置器的部分源码
template <int inst>
class __malloc_alloc_template
{
private:
static void* oom_malloc(size_t);
public:
// 对malloc的封装
static void* allocate(size_t n)
{
// 申请空间成功，直接返回，失败交由oom_malloc处理
void* result = malloc(n);
if (0 == result)
result = oom_malloc(n);
return result;
}
// 对free的封装
static void deallocate(void* p, size_t /* n */)
{
free(p);
}
};SGI-STL默认使用一级空间配置器还是二级空间配置器，是通过USE_MALLOC宏进行控制的（但默认使用二级空间配置器）：
cpp
#ifdef __USE_MALLOC
typedef malloc_alloc alloc;
typedef malloc_alloc single_client_alloc;
#else
// 二级空间配置器定义
#endif二、二级空间配置器
1.原理
二级空间配置器的原理相对复杂，采用了内存池 来提高申请空间的速度和减少额外的空间开销，通过哈希桶来提高用户获取空间的速度和管理的效率，专门处理小块内存。
【补】内存池技术
事先申请一块较大的空间资源备用，需要内存时，直接从这块空间资源中获取。当空间不够时，再使用malloc申请补充，当空间不使用时，直接归还这块空间资源即可。这块事先申请的空间就是内存池，它避免了频繁向系统申请小块内存所造成的效率低、内存碎片、额外浪费等问题。
cpp
//二级空间配置器的部分源码
template <int inst>
class __default_alloc_template
{
//...
//二级空间配置器中存在3个成员变量：
char* start; //内存池的起始地址
char* end; //内存池的结束地址
size_t heap_size; //内存池的大小
};
二级空间配置器的逻辑结构如上图，由内存池和哈希桶组成。内存池负责向系统申请空间资源并将它们集中保存起来，哈希桶负责对这些资源归类、编号等管理操作。哈希桶的每个哈希地址，对应这个位置上所挂的每个桶的大小（也就是申请的空间大小），它们之间存在对齐，且一定是8的倍数（但不超过128）。
（64位平台下，指针的大小为8个字节。联合体使指向下一个桶的指针变量和实际管理空间资源的指针数组，共用了这个指针数组的空间。这也是为什么哈希地址采用8的倍数来对齐）。
假设现在要为list对象new一个16字节大小的节点，而此时内存池是空的，哈希桶中也是空的：
首先去哈希桶中找到相应的哈希地址，查验是否有空间资源可以拿来用（目前哈希桶是空的，所以没有）；哈希桶没有，就去内存池中，查验是否有空间资源可以拿来用（目前内存池也是空的，所以没有）；内存池也没有，就通过malloc向系统申请，申请好后放在内存池中（但不是只申请16个字节，而是申请多组"16个字节"，这是因为STL中采样一次要20组"16个字节"的资源，也就是一共320个字节）。
此时内存池中就有20组"16个字节"的资源了。new一个16字节大小的节点需要用到一组资源，所以就拿走1组给list对象使用，剩下的19组就挂在哈希桶中相应的哈希地址下。如果之后还要new一个节点，就从哈希桶中拿走一组资源使用；如果要释放一个节点，就把一组资源归还到哈希桶中，如果之后还要new一个节点，就可以继续用归还的资源。如果new的是一个6字节大小的节点，就在哈希桶中找到哈希地址为8的桶，取走相应的资源。
【Tips】 二级空间配置器的原理
为容器开空间时，会先去哈希桶中索要空间资源；如果哈希桶没有，就继续向内存池索要；如果内存池也没有，就通过malloc向系统申请；如果系统也没有了（即malloc失败），就去找还剩了资源（没用完）的桶，把用过的和剩下的部分分隔开，用剩下的资源；如果都没有了，就抛异常。
2.空间申请
2-1.基本结构
cpp
// 部分源码
template <int inst>
class __default_alloc_template
{
private:
enum { __ALIGN = 8 }; // 如果用户所需内存不是8的整数倍，向上对齐到8的整数倍
enum { __MAX_BYTES = 128 }; // 大小内存块的分界线
enum { __NFREELISTS = __MAX_BYTES / __ALIGN };//采用哈希桶保存小块内存时所需桶的个数
// 如果用户所需内存块不是8的整数倍，向上对齐到8的整数倍
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:
static obj* free_list[__NFREELISTS];
// 哈希函数，根据用户提供字节数找到对应的桶号
static size_t FREELIST_INDEX(size_t bytes)
{
return (((bytes)+__ALIGN - 1) / __ALIGN - 1);
}
// start_free与end_free用来标记内存池中大块内存的起始与末尾位置
static char* start_free;
static char* end_free;
// 用来记录该空间配置器已经想系统索要了多少的内存块
static size_t heap_size;
// ...
};2-2.申请资源
cpp
// 函数功能：向空间配置器索要空间
// 参数n: 用户所需空间字节数
// 返回值：返回空间的首地址
static void* allocate(size_t n)
{
obj* __VOLATILE* my_free_list;
obj* __RESTRICT result;
// 检测用户所需空间释放超过128(即是否为小块内存)
if (n > (size_t)__MAX_BYTES)
{
// 不是小块内存交由一级空间配置器处理
return (malloc_alloc::allocate(n));
}
// 根据用户所需字节找到对应的桶号
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
// 如果该桶中没有内存块时，向该桶中补充空间
if (result == 0)
{
// 将n向上对齐到8的整数被，保证向桶中补充内存块时，内存块一定是8的整数倍
void* r = refill(ROUND_UP(n));
return r;
}
// 维护桶中剩余内存块的链式关系
*my_free_list = result->free_list_link;
return (result);
};2-3. 填充内存块
cpp
// 函数功能：向哈希桶中补充空间
// 参数n：小块内存字节数
// 返回值：首个小块内存的首地址
template <int inst>
void* __default_alloc_template<inst>::refill(size_t n)
{
// 一次性向内存池索要20个n字节的小块内存
int nobjs = 20;
char* chunk = chunk_alloc(n, nobjs);
obj** 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.向内存池中索要空间
cpp
template <int inst>
char* __default_alloc_template<inst>::chunk_alloc(size_t size, int& nobjs)
{
// 计算nobjs个size字节内存块的总大小以及内存池中剩余空间总大小
char* result;
size_t total_bytes = size * nobjs;
size_t bytes_left = end_free - start_free;
// 如果内存池可以提供total_bytes字节，返回
if (bytes_left >= total_bytes)
{
result = start_free;
start_free += total_bytes;
return(result);
}
else if (bytes_left >= size)
{
// nobjs块无法提供，但是至少可以提供1块size字节内存块，提供后返回
nobjs = bytes_left / size;
total_bytes = size * nobjs;
result = start_free;
start_free += total_bytes;
return(result);
}
else
{
// 内存池空间不足，连一块小块村内都不能提供
// 向系统堆求助，往内存池中补充空间
// 计算向内存中补充空间大小：本次空间总大小两倍 + 向系统申请总大小/16
size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
// 如果内存池有剩余空间(该空间一定是8的整数倍)，将该空间挂到对应哈希桶中
if (bytes_left > 0)
{
// 找对用哈希桶，将剩余空间挂在其上
obj** my_free_list = free_list + FREELIST_INDEX(bytes_left);
((obj*)start_free)->free_list_link = *my_free_list;
*my_ree_list = (obj*)start_free;
}
// 通过系统堆向内存池补充空间，如果补充成功，递归继续分配
start_free = (char*)malloc(bytes_to_get);
if (0 == start_free)
{
// 通过系统堆补充空间失败，在哈希桶中找是否有没有使用的较大的内存块
int i;
obj** my_free_list, * p;
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));
}
}
// 山穷水尽，只能向一级空间配置器求助
// 注意：此处一定要将end_free置空，因为一级空间配置器一旦抛异常就会出问题
end_free = 0;
start_free = (char*)malloc_alloc::allocate(bytes_to_get);
}
// 通过系统堆向内存池补充空间成功，更新信息并继续分配
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
return(chunk_alloc(size, nobjs));
}
}3.空间释放
cpp
// 函数功能：用户将空间归还给空间配置器
// 参数：p空间首地址 n空间总大小
static void deallocate(void* p, size_t n)
{
obj* q = (obj*)p;
obj** 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;
}4.对象与空间资源
出于高效和安全的考虑，空间申请释放和对象的构造析构这两个过程是分开进行的（因为存在一些对象的初始化不需要调用构造函数，生命周期结束时不需要调用析构函数）：
cpp
// 归还空间时，先先调用该函数将对象中资源清理掉
template <class T>
inline void destroy(T* pointer)
{
pointer->~T();
}
// 空间申请好后调用该函数：利用placement-new完成对象的构造
template <class T1, class T2>
inline void construct(T1* p, const T2& value)
{
new (p) T1(value);
}
//注意：
//1. 在释放对象时，需要根据对象的类型确定是否调用析构函数(类型萃取)
//2. 对象的类型可以通过迭代器获萃取到5.与容器结合
cpp
//例：list与空间配置器的结合
template <class T, class Alloc = alloc>
class list
{
// ...
// 实例化空间配置器
typedef simple_alloc<list_node, Alloc> list_node_allocator;
// ...
protected:
link_type get_node()
{
// 调用空间配置器接口先申请节点的空间
return list_node_allocator::allocate();
}
// 将节点归还给空间配置器
void put_node(link_type p)
{
list_node_allocator::deallocate(p);
}
// 创建节点：1. 申请空间 2. 完成节点构造
link_type create_node(const T& x)
{
link_type p = get_node();
construct(&p->data, x);
return p;
}
// 销毁节点： 1. 调用析构函数清理节点中资源 2. 将节点空间归还给空间配置器
void destroy_node(link_type p)
{
destroy(&p->data);
put_node(p);
}
// ...
iterator insert(iterator position, const T& x)
{
link_type tmp = create_node(x);
tmp->next = position.node;
tmp->prev = position.node->prev;
(link_type(position.node->prev))->next = tmp;
position.node->prev = tmp;
return tmp;
}
iterator erase(iterator position)
{
link_type next_node = link_type(position.node->next);
link_type prev_node = link_type(position.node->prev);
prev_node->next = next_node;
next_node->prev = prev_node;
destroy_node(position.node);
return iterator(next_node);
}
// ...
};
//注：
//空间配置器一般只存在一个，
//所以它可以是一个单例对象，不同的容器甚至是不同线程都可以使用
//比如map归还的空间set也可以继续使用。补、STL六大件三大类
从功能上讲，STL可以分为六大组件，分别是容器、迭代器、算法、仿函数、适配器、空间配置器。
- 容器：容器是STL最基础的组件，没有容器，就没有数据，容器的作用就是用来存储数据的，在不同的场景下使用不同的容器，保证了数据使用的高效率和低空间。
- 算法：算法是解决问题的思想和实施步骤；而编程就是算法的实现，不同算法的实现对于数据的处理来说是重要的，没有算法，也就没有了正确的数据。
- 迭代器：迭代器的出现连接了容器和算法，隐藏了算法和容器底层的实现细节，降低了使用成本，如果没有迭代器，则算法和容器将直接暴露在用户面前，使封装性减低。
- 适配器：通过其他的容器或迭代器来实现其它的容器或迭代器，stack/queue/priority_queue都是通过其它容器适配出来的，反向迭代器也可以通过正向迭代器实现。
- 仿函数：通过实现operator()的类，这个类对象可以像函数一样来实现，比如map/set中key的比较大小，sort中的比较规则。
- 空间配置器(内存池）：容器频繁申请或释放内存。判断申请的空间大小来使用不同的内存池，减小了空间的浪费，提高了访问效率。
如果从代码广义上讲，STL又可以分为三类：容器、迭代器、算法。几乎所有的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。
STL 的中心思想在于，将数据容器和算法分开，彼此独立设计，最后以一帖胶着剂（迭代器）将它们撮合在一起。正是这种分离的设计，使得STL非常通用。例如，sort()能为数据集合排序，这其中包括普通的数组、容器等。
STL主要具有的是泛型编程的特性，并非面向对象的。为了具有足够通用性，STL主要依赖于模板，而不是面向对象的三要素------封装、继承和多态性，所以在 STL 中找不到任何明显的类继承关系。