deque容器

之前有写到的vector易于做random_access，对于插入涉及到内存重分配，而对于list适合做insert/erase但是对于随机取值只能遍历。

是不是有一种结合两者的做法呢?那就是deque。

deque的实现思路是这样的：

（1）内存的不连续，划分成一段一段的，每段可以存储相同个数的元素。

（2）每段内存存储的地址用一个专门的数组保存起来。

（3）对于随机取值可以直接计算出落在哪段内存区间的哪个位置。（取整和取余运算）

（4）插入元素时，保存指针的数组由于是连续内存区间，所以涉及到重新保存指针数组的内存重新申请和拷贝，相对于元素拷贝代价小。

（5）对于随机插入没能避免元素拷贝。

deque的实现，成员变量是deque的迭代器，所以我们先看迭代器的实现。

template <class _Tp, class _Ref, class _Ptr>struct _Deque_iterator {typedef _Tp** _Map_pointer; _Tp* _M_cur;            //此段内存迭代器指针  _Tp* _M_first;         //此段内存首地址  _Tp* _M_last;          //此段内存end    _Map_pointer _M_node;//指针数组的值，标识某一段元素内存}

迭代器加减预算

  _Self& operator+=(difference_type __n)  {    difference_type __offset = __n + (_M_cur - _M_first);    //_S_buffer_size()表示每段内存容纳多少的元素T  等于__size < 512 ? size_t(512 / __size) : size_t(1)    if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))      _M_cur += __n;       //在同一段内存区间    else {      difference_type __node_offset =        __offset > 0 ? __offset / difference_type(_S_buffer_size())                   : -difference_type((-__offset - 1) / _S_buffer_size()) - 1;//内存段偏移      _M_set_node(_M_node + __node_offset);      _M_cur = _M_first +         (__offset - __node_offset * difference_type(_S_buffer_size())); //元素偏移    }    return *this;  }

_Deque_base的实现包含4个重要的成员数据：

  _Tp** _M_map;          //指针数组       size_t _M_map_size;    //指针数组大小  iterator _M_start;     //标识第一个内存段  iterator _M_finish;    //标识最后一个内存段（这是一个闭合区间，和deque的迭代器_M_last半开区间不一样）

构造_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);  }

先把指针数组创建出来吧

template <class _Tp, class _Alloc>void_Deque_base<_Tp,_Alloc>::_M_initialize_map(size_t __num_elements){  size_t __num_nodes =     __num_elements / __deque_buf_size(sizeof(_Tp)) + 1;   //_S_init_map_size=8 加2是为了之后方便push元素  _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);  _M_map = _M_allocate_map(_M_map_size);   //由于是双向表结构，把start放到中间去  _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2;  _Tp** __nfinish = __nstart + __num_nodes;      __STL_TRY {    _M_create_nodes(__nstart, __nfinish);  }  __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size),                 _M_map = 0, _M_map_size = 0));  _M_start._M_set_node(__nstart);  _M_finish._M_set_node(__nfinish - 1); //闭合区间  _M_start._M_cur = _M_start._M_first;  _M_finish._M_cur = _M_finish._M_first +               __num_elements % __deque_buf_size(sizeof(_Tp));//finish的cur指到最后一个元素去（开区间）}

插入元素

  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      _M_push_back_aux(__t);       //需下一段内存  }

在下一段内存插入

template <class _Tp, class _Alloc>void deque<_Tp,_Alloc>::_M_push_back_aux(const value_type& __t){  value_type __t_copy = __t;  _M_reserve_map_at_back();            //判断是否需要扩充指针数组  *(_M_finish._M_node + 1) = _M_allocate_node();  __STL_TRY {    construct(_M_finish._M_cur, __t_copy);    _M_finish._M_set_node(_M_finish._M_node + 1);    _M_finish._M_cur = _M_finish._M_first;  }  __STL_UNWIND(_M_deallocate_node(*(_M_finish._M_node + 1)));}

指针数组重新分配

 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 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;  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;  _Map_pointer __new_nstart;  if (_M_map_size > 2 * __new_num_nodes) {    __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_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);    _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);}

随机插入就要命了。。

template <class _Tp, class _Alloc>void deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos,                                      size_type __n,                                      const value_type& __x)

函数实现主要依赖迭代器进行元素拷贝

        uninitialized_copy(_M_start, __start_n, __new_start);        _M_start = __new_start;        copy(__start_n, __pos, __old_start);

对于deque的每一句代码实现没有细看，总的思想就是这些

（1）不连续内存，指针拷贝避免元素拷贝

（2）随机取值可直接计算复杂度O(1)

（3）不解决随机插入问题，预分配指针数组空间便于之后的前后push