stl有容器，空间配置器，适配器，迭代器，仿函数以及算法这6个组件
它们六者关系大概如下：容器通过配置器取得数据存储空间,算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套界仿函数。
1.STL空间配置器的类型和标准接口定义
（1）类型
allocator::value_type; allocator::pointer; allocator::const_pointer; allocator::reference; allocator::const_reference; allocator::size_type; allocator::difference_type;
（2）标准接口
allocator::rebind // 一个嵌套的class template，class rebind<U>拥有唯一成员other，那是一个typedef，代表allocator<U> allocator::allocator() // default constructor allocator::allocator(const allocator&) // copy constructor template <class U>allocator::allocator<const allocator<U>&() // generic copy constructor allocator::~allocator() // default constructor pointer allocator::address(reference x) const // 返回对象的地址，等同于&x const_pointer allocator::address(const_reference x)const // 返回对象的地址，等同于&x pointer allocator::allocate(size_type n, const void* = 0) // 配置空间，足以存储n个T对象，第二参数是个提示，实现上可能利用它来增进区域性，或完全忽略之 void allocator::deallocate(pinter p, size_type n) // 归还之前配置的空间 size_type allocator::max_size() const // 按返回可成功配置的最大空间 void allocator::constructor(pointer p, const T&x) // 等同于 new(const void* p ) T(x) 即placement new void allocator::destroy(pinter p) // 等同于 p->~T()
2.关于内存碎片问题
3.STL的两层空间配置器
由于以上的问题，SGI设计了两层的配置器，也就是第一级配置器和第二级配置器。同时为了自由选择，STL又规定了 __USE_MALLOC 宏，如果它存在则直接调用第一级配置器，不然则直接调用第二级配置器。SGI未定义该宏，也就是说默认使用第二级配置器。
需要注意的是，SGI版STL提供了一层更高级的封装，定义了一个simple_alloc类，无论是用哪一级都以模板参数alloc传给simple_alloc，这样对外体现都是只是simple_alloc
而它的代码实现比较简单，仅仅是调用一级或者二级配置器的接口
template<class T, class Alloc = AllocToUse>
class SimpleAlloc
{
public:
static T* Allocate()
{
return (T*)Alloc::Allocate(sizeof(T));
}
static T* Allocate(size_t n)
{
return n == 0 ? 0 : (T*)Alloc::Allocate(n * sizeof(T));
}
static void Deallocate(T* p)
{
if (p != NULL)
return Alloc::Deallocate(p, sizeof(T));
}
static void Deallocate(T* p, size_t n)
{
return Alloc::Deallocate(p, n * sizeof(T));
}
};
4.第一级空间配置器实现
一级空间配置器就比较简单了，STL源码中的一级空间配置器命名为class __malloc_alloc_template ，它很简单，就是对malloc，free，realloc等系统分配函数的一层封装，我向这也是为什么这么取名的原因
#if 0
#include <new>
#define __THROW_BAD_ALLOC throw bas_alloc
#elif !defined(__THROW_BAD_ALLOC)
#include <iostream.h>
#define __THROW_BAD_ALLOC cerr << "out od memory" << endl; exit(1)
#endif
template <int inst>
class __malloc_alloc_template
{
private:
// oom: out of memory
static void *oom_malloc(size_t);
static void *oom_realloc(void *,size_t);
static void (* __malloc_alloc_oom_handler)();
public:
static void* allocate(size_t n)
{
void *result = malloc(n); // 第一级配置器直接使用malloc
if (NULL == result)
{
result = oom_malloc(n); // 不满足时改用oom_malloc
}
return result;
}
static void* deallocate(void* p,,size_t /* n */)
{
free(p); // 第一级配置器直接使用free
}
static void* reallocate(void *p,size_t /* 0ld_sz */,size_t new_sz)
{
void * result = realloc(p,new_sz); // 第一级配置器直接使用realloc
if (NULL == result)
{
result= oom_realloc(p,new_sz);// 不满足时改用oom_realloc
}
return result;
}
// 模拟C++的set_new_handler,可以指定自己的oom handler
static void (* set_malloc_handler(void (*f)(void)))(void)
{
void (*lod)() = __malloc_alloc_oom_handler;
__malloc_alloc_oom_handler = f;
return (old);
}
};
template <int inst>
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;
template <int inst>
void * __malloc_alloc_template<inst>::oom_malloc(size_t n)
{
void (*my_malloc_handler)();
void *result;
while (1) // 不断尝试释放，配置，再释放，再配置
{
my_malloc_handler = __malloc_alloc_oom_handler;
if (NULL == 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;
while (1) // 不断尝试释放，配置，再释放，再配置
{
my_malloc_handler = __malloc_alloc_oom_handler;
if (NULL == my_malloc_handler)
{
__THROW_BAD_ALLOC;
}
(*my_malloc_handler)(); // 呼叫处理例程，企图释放内存
result = realloc(p,n); // 再次尝试配置内存
if (result)
{
return result;
}
}
}
// 直接将参数inst指定为0
typedef __malloc_alloc_template<0> malloc_alloc
一级空间配置器中没有可以讨论的，除了这个句柄函数：static void(*SetMallocHandler(void(*f)()))();对于一个C初学者来说想要看懂这个声明有点难度，这是一个返回值，参数都为函数指针的一个函数指针。填起来有点绕，其实他就是一个函数指针，它指向的是一个句柄函数，这个句柄函数对于一级空间配置器是比较重要的。
malloc，free，realloc等库函数是向系统申请内存并且操作的函数。平时我们并不太会遇到内存空间分配不出来的情况，但是如果这一套程序是运行在服务器上的，各种各样的进程都需要内存。这样频繁的分配内存，终有一个时候，服务器再也分配不出内存，那么空间配置器该怎么办呢？这个函数指针指向的句柄函数就是处理这种情况的设计。
5.第二级空间配置器实现
根据情况来判定，如果配置区块大于128bytes，说明“足够大”，调用第一级配置器，而小于等于128bytes，则采用复杂内存池（memory pool）来管理。
template <bool threads, int inst>
class __default_alloc_template
{
private:
// 实际上我们应该使用 static const int x = N
// 来取代 enum { x = N }, 但目前支持该性质的编译器还不多。
# ifndef __SUNPRO_CC
enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};
# endif
//注意此处的位运算技巧，将bytes上调至8的倍数
static size_t ROUND_UP(size_t bytes)
{
return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
}
//注意此处的union技巧
union obj
{
union obj* free_list_link;
char client_data[1]; /* The client sees this. */
};
private:
# ifdef __SUNPRO_CC
static obj * __VOLATILE free_list[];
// Specifying a size results in duplicate def for 4.1
# else
static obj * __VOLATILE free_list[__NFREELISTS];
# endif
static size_t FREELIST_INDEX(size_t bytes)
{
return (((bytes) + __ALIGN - 1) / __ALIGN - 1);
}
// 传回一个大小为n的对象，并可能加入大小为n的其他区块到free list
static void *refill(size_t n);
// 配置一大块空间，可容纳nobjs个大小为“size”的区块
// 如果配置nobjs个区块有所不便，nobjs可能会降低
static char *chunk_alloc(size_t size, int &nobjs);
// Chunk allocation state.
static char *start_free; // 记忆池起始位置，只在chunk_alloc()中变化
static char *end_free; // 记忆池结束位置，只在chunk_alloc()中变化
static size_t heap_size;
// 判断区块大小，大于128bytes就呼叫第一级配置器，小于128bytes就检查相应的free list。
// 如果free list之内有可用的区块，就直接拿来用。如果没有可用的区块，就将区块大小上调至8的倍数，然后呼叫refill
/* n must be > 0 */
static void * allocate(size_t n)
{
obj *volatile *my_free_list;
obj *result;
// 大于128bytes就呼叫第一级配置器
if (n > (size_t)__MAX_BYTES)
{
return (malloc_alloc::allocate(n));
}
// 否则，在free_list寻找合适的一个
my_free_list = free_list + FREELIST_INDEX(n);
result = *my_free_list;
if (NULL == result)
{
void *r = refill(ROUND_UP(n));// 如果没有合适的，就将n上调至8的倍数
return r;
}
// 调整free list
*my_free_list = result->free_list_link;
return result;
}
// n大于128bytes就呼叫第一级配置器，小于128bytes就找出对应的free list将区块回收
/* p may not be 0 */
static void deallocate(void *p, size_t n)
{
obj *q = (obj*)p;;
obj * volatile * my_free_list;
// 大于128bytes就呼叫第一级配置器
if (n > (size_t)__MAX_BYTES)
{
malloc_alloc::deallocate(p,n);
return;
}
// 否则，寻找对应的free list
my_free_list = free_list + FREELIST_INDEX(n);
// 调整free list，回收区块
q->free_list_link = *my_free_list;
*my_free_list = q;
}
static void * reallocate(void *p, size_t old_sz, size_t new_sz);
// 以下是静态数据成员的定义和初始化
template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::start_free = 0;//内存池起始位置
template <bool threads, int inst>
char *__default_alloc_template<threads, inst>::end_free = 0;//内存池结束位置
template <bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;
template <bool threads, int inst>
__default_alloc_template<threads, inst>::obj * __VOLATILE
__default_alloc_template<threads, inst> ::free_list[
# ifdef __SUNPRO_CC
__NFREELISTS
# else
__default_alloc_template<threads, inst>::__NFREELISTS
# endif
] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
};
// 几个调用的全域函数
// refill()，传回一个大小为n的对象，并且有时候会为适当的free list增加节点
// 假设n已经适当上调至8的倍数
template <bool threads,int inst>
void * __default_alloc_template<threads,inst>::refill(size_t n)
{
int nobjs = 20;
// 呼叫chunk_alloc(),尝试获得nobjs个区块作为free list的新节点
char * chunk = chunk_alloc(n,nobjs);
obj * volatile *my_free_list;
obj * result;
obj * current_obj,*next_obj;
int i;
// 如果只获得一个区块，这个区块就拨给呼叫者用，free list无新节点
if (1 == nobjs)
{
return chunk;
}
// 否则准备调整free list，纳入新节点
my_free_list = free_list + FREELIST_INDEX(n);
// 以下在chunk空间建立free list
result = (obj*)chunk; // 这一块准备传回给客端
// 以下导引free list指向新配置的空间（取自记忆池）
*my_free_list = next_obj = (obj*)(chunk + n);
// 以下将free list的各节点串接起来
for (i = 1; ; i++) // 从1开始，因为第0个传回给客端
{
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;
}
// 假设size已经适当上调至8的倍数
template <bool threads,int inst>
char * __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 = 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)
{
// 首先寻找合适的free list
obj* volatile* my_free_list = free_list + FREELIST_INDEX(bytes_left);
// 调整free list，将记忆池中的残余空间编入
((obj*)start_free)->free_list_link = *my_free_list;
*my_free_list = (obj*)start_free;
}
// 配置heap空间
start_free = (char *)malloc(bytes_to_get);
if (NULL == start_free)
{
// heap空间不足，malloc失败
int i;
obj* volatile* my_fress_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) // free list内尚有未用区块
{
// 调整free list以释放出未用区块
*my_free_list = p->free_list_link;
start_free = (char*)p;
end_free = start_free + i;
// 递归呼叫自己，为了修正nobjs
return (chunk_alloc(size,nobjs));
// 注意，任何残余零头终将会被编入适当的free list中备用
}
}
end_free = 0;
// 呼叫第一级配置器，看看oom机制能否尽点力
start_free = (char*)malloc_alloc::allocate(bytes_to_get);
}
heap_size += bytes_to_get;
end_free = start_free + bytes_to_get;
// 递归呼叫自己，为了修正nobjs
return (chunk_alloc(size,nobjs));
}
}
obj * volatile * my_free_list这个声明原来的形式是：obj** my_free_list，这样的话*my_free_list（空闲的内存块指针数组中的一个元素）可能被优化到寄存器中，从而使库代码无法lock住对它的读调用（如果在寄存器中则另一个线程可能会无意中修改该寄存器的值，而在内存中由于另一个线程没有访问权力所以不能修改）。
要声明变量必须在内存中就要用volatile修饰，这里修饰的是*my_free_list，是free_list数组中的一个元素，而不是数组指针，所以volatile放在两个*中间。
来源：https://blog.csdn.net/syyon123456789/article/details/51495740
（1）allocate函数分析
- 如果用户需要的区块大于128，则直接调用第一级空间配置器
- 如果用户需要的区块大于128，则到自由链表中去找
- 如果自由链表有，则直接去取走
- 不然则需要装填自由链表（Refill）
- 如果区块大于128， 则直接由第一级空间配置器收回
- 如果区块小于等于128， 则有自由链表收回
（3）chunkalloc函数分析
如果用户需要是一块n字节的区块，且n <= 128（调用第二级配置器），此时Refill填充是这样的：（需要注意的是：系统会自动将n字节扩展到8的倍数也就是RoundUP（n），再将RoundUP（n）传给Refill）。用户需要n块，且自由链表中没有，因此系统会向内存池申请nobjs * n大小的内存块，默认nobjs=20
- 如果内存池大于 nobjs * n，那么直接从内存池中取出
- 如果内存池小于nobjs * n，但是比一块大小n要大，那么此时将内存最大可分配的块数给自由链表，并且更新nobjs为最大分配块数x （x < nobjs）
- 如果内存池连一个区块的大小n都无法提供，那么首先先将内存池残余的零头给挂在自由链表上，然后向系统heap申请空间，申请成功则返回，申请失败则到自己的自由链表中看看还有没有可用区块返回，如果连自由链表都没了最后会调用一级配置器
- 如果只有一块返回给调用者，有多块，返回给调用者一块，剩下的挂在对应的位置。
6.什么是自由链表
扫描二维码关注公众号，回复：
1478788 查看本文章
我们在上面重点分析了整体思路，也就是二级配置器如何配置和是否内存，他们和一级配置器一样都提供Allocate和Deallocate的接口（其实还有个Reallocate也是用于分配内存，类似于C语言中realloc函数），我们都提到了一点自由链表，那么自由链表是个什么？
如上图所示，自由链表是一个指针数组，有点类似与hash桶，它的数组大小为16，每个数组元素代表所挂的区块大小，比如free_list[0]代表下面挂的是8bytes的区块，free_list[1]代表下面挂的是16bytes的区块…….依次类推，直到free _ list[15]代表下面挂的是128bytes的区块
同时我们还有一个被称为内存池地方，以start _ free和 end _ free记录其大小，用于保存未被挂在自由链表的区块，它和自由链表构成了伙伴系统。
我们之前讲了，如果用户申请小于等于128的区块，就到自由链表中取，但是如果自由链表对应的位置没了怎么办？？？这下子我们的内存池就发挥作用了！
7.最后
也就是STL可能存在的问题，通俗的讲就是优缺点吧
我们知道，引入相对的复杂的空间配置器，主要源自两点：
1. 频繁使用malloc，free开辟释放小块内存带来的性能效率的低下
2. 内存碎片问题，导致不连续内存不可用的浪费
引入两层配置器帮我们解决以上的问题，但是也带来一些问题：
- 内碎片的问题，自由链表所挂区块都是8的整数倍，因此当我们需要非8倍数的区块，往往会导致浪费，比如我只要1字节的大小，但是自由链表最低分配8块，也就是浪费了7字节，我以为这也就是通常的以空间换时间的做法，这一点在计算机科学中很常见。
- 我们发现似乎没有释放自由链表所挂区块的函数？确实是的，由于配置器的所有方法，成员都是静态的，那么他们就是存放在静态区。释放时机就是程序结束，这样子会导致自由链表一直占用内存，自己进程可以用，其他进程却用不了。
来源：https://blog.csdn.net/xy913741894/article/details/66974004