STL 所有容器应用到了空间配置器，当然 deque 在 _Deque_base 中设置了 两个空间配置器，一个负责缓冲区元素的空间配置，一个负责中控器map的指针空间配置：
typedef simple_alloc<_Tp, _Alloc> _Node_alloc_type; //负责缓冲区元素空间配置
typedef simple_alloc<_Tp*, _Alloc> _Map_alloc_type; //负责中控器map的指针空间配置
当然可以追溯下元素空间配置用的配置器是啥：
typedef typename _Base::allocator_type allocator_type; allocator_type get_allocator() const { return _Base::get_allocator(); }
咱们看看 _Base::get_allocator() 在哪里
typedef _Alloc allocator_type; allocator_type get_allocator() const { return allocator_type(); }
可以知道，其实 _Base::get_allocator() 还是默认的空间配置器 _Alloc；
deque 提供的 constructor 如下：
//拷贝构造函数
deque(const deque& __x) : _Base(__x.get_allocator(), __x.size()) { uninitialized_copy(__x.begin(), __x.end(), _M_start); }
//真正的构造函数 deque(size_type __n, const value_type& __value, const allocator_type& __a = allocator_type()) : _Base(__a, __n) { _M_fill_initialize(__value); }
_Base（__a，__n）负责产生并安排好 deque 的结构，看一下_M_fill_initialized 在哪里，如下，该函数将元素的初值设定妥当：
template <class _Tp, class _Alloc> void deque<_Tp,_Alloc>::_M_fill_initialize(const value_type& __value) { _Map_pointer __cur; __STL_TRY {
//为每个节点的缓冲区设定初值 for (__cur = _M_start._M_node; __cur < _M_finish._M_node; ++__cur) { uninitialized_fill(*__cur, *__cur + _S_buffer_size(), __value); }
//最后一个节点的设定稍有不同（因为尾端可能有备用空间，不必设初值） uninitialized_fill(_M_finish._M_first, _M_finish._M_cur, __value); }
//失败就销毁已经配置好的 STL_UNWIND(destroy(_M_start, iterator(*__cur, __cur))); }
也看一下_Base（__a，__n）如何设定deque结构，根据 typedef _Deque_base<_Tp, _Alloc> _Base，找到_Deque_base构造函数如下：
_Deque_base(const allocator_type&, size_t __num_elements) : _M_map(0), _M_map_size(0), _M_start(), _M_finish() { _M_initialize_map(__num_elements); }
初始化_M_map等，这里就不多说了，找一下_M_initialize_map 函数
template <class _Tp, class _Alloc> void _Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements) { //节点数 = 元素总的个数 / 缓冲区大小 再 + 1; size_t __num_nodes = __num_elements / __deque_buf_size(sizeof(_Tp)) + 1; //中控器大小，最少为初始设定个数8个，最多“所需节点数 + 2” _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2); //配置具有_M_map_size个节点的map中控器 _M_map = _M_allocate_map(_M_map_size); //设置头部和尾部 _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2; _Tp** __nfinish = __nstart + __num_nodes; __STL_TRY { //为中控器map中每个节点配置缓冲区 _M_create_nodes(__nstart, __nfinish); } //失败则撤销操作并释放空间 __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size), _M_map = 0, _M_map_size = 0)); //为deque内的两个迭代_M_start 和 _M_finish更新内容 _M_start._M_set_node(__nstart); _M_finish._M_set_node(__nfinish - 1); _M_start._M_cur = _M_start._M_first; //多配置一个节点，_M_cur指向多配置的节点起始处 _M_finish._M_cur = _M_finish._M_first + __num_elements % __deque_buf_size(sizeof(_Tp)); }
接下来是push_back()函数，push_back()函数首先判断在缓冲区是否有两个以上的元素备用空间，如果有则直接构造，没有就调用push_back_aux()函数，先配置一块新的缓冲区，然后设置新元素内容，然后更改迭代器 finish 状态：
void push_back(const value_type& __t) { //先判断是否有备用空间 if (_M_finish._M_cur != _M_finish._M_last - 1) { construct(_M_finish._M_cur, __t); ++_M_finish._M_cur; } else //没有就调用该函数进行配置新的空间，并设置finish状态 _M_push_back_aux(__t); }
咱们再来看一下_M_push_back() 和 _M_push_front()函数，_M_push_back()函数是当map尾部没有多余节点存储指向新的缓冲区的新指针的时候，需要额外在尾部继续开辟一个新的空间，来存放新的指针，同理，_M_push_front（）函数在头部开辟新的空间来存储指针，当然要满足空间不足的前提。
//当map尾部还剩下一个节点（节点存取指向缓冲区的指针）时，就必须重新换一个map，配置更大的，拷贝原来的，释放原来的
void _M_reserve_map_at_back (size_type __nodes_to_add = 1)
{ if (__nodes_to_add + 1 > _M_map_size - (_M_finish._M_node - _M_map)) _M_reallocate_map(__nodes_to_add, false); } //同理，头部也是该操作 void _M_reserve_map_at_front (size_type __nodes_to_add = 1) { if (__nodes_to_add > size_type(_M_start._M_node - _M_map)) _M_reallocate_map(__nodes_to_add, true); }
特别的，当map很大，需要开辟额外的新的一块内存用来迁移map时，就会调用_M_reallocate_map来开辟新的内存，如下：
template <class _Tp, class _Alloc> void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add, bool __add_at_front) { size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1; //旧的map的size size_type __new_num_nodes = __old_num_nodes + __nodes_to_add; //新的map的size _Map_pointer __new_nstart; if (_M_map_size > 2 * __new_num_nodes) //map目前的size如果大于两倍的新的size { __new_nstart = _M_map + (_M_map_size - __new_num_nodes) / 2 + (__add_at_front ? __nodes_to_add : 0); if (__new_nstart < _M_start._M_node) copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); else copy_backward(_M_start._M_node, _M_finish._M_node + 1, __new_nstart + __old_num_nodes); } else { size_type __new_map_size = _M_map_size + max(_M_map_size, __nodes_to_add) + 2; //配置一块空间，给map用 _Map_pointer __new_map = _M_allocate_map(__new_map_size); __new_nstart = __new_map + (__new_map_size - __new_num_nodes) / 2 + (__add_at_front ? __nodes_to_add : 0); copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart); _M_deallocate_map(_M_map, _M_map_size); //设定新map起始地点大小 _M_map = __new_map; _M_map_size = __new_map_size; }
//重新设置开始迭代器和结束迭代器 _M_start._M_set_node(__new_nstart); _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1); }