STL之deque

Posted 2020-11-21 randyniu

deque为了维持在头和尾进行插入的假象，这些操作全部都交给了迭代器去做了。

deque由一段一段定量连续空间构成，一旦有必要在deque的前端或者是尾端增加新的空间，便配置一段定量的连续空间，串在头部或者是尾部。

deque采用的是一块所谓的map作为主控，这里的map是一小段连续的空间，其中每个元素都是一个指针，指向另一端较大的连续线性空间，称为缓冲区。缓冲区才是真正的存储主体。允许指定大小的缓冲区，默认是512字节的缓冲区。

//deque迭代器的设计
//*deque是分段连续的线性空间，迭代器设计时必须能够进行operator++或operator--操作
//*    迭代器的功能：
//*    1、必须知道缓冲区的位置
//*    2、能够判断是否处于其所在缓冲区的边界
//*    3、能够知道其所在缓冲区当前所指位置的元素
//********************************************
template <class _Tp, class _Ref, class _Ptr>
struct _Deque_iterator {
  typedef _Deque_iterator<_Tp, _Tp&, _Tp*>             iterator;
  typedef _Deque_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
  static size_t _S_buffer_size() { return __deque_buf_size(sizeof(_Tp)); }

  typedef random_access_iterator_tag iterator_category;
  typedef _Tp value_type;
  typedef _Ptr pointer;
  typedef _Ref reference;
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;
  typedef _Tp** _Map_pointer;

  typedef _Deque_iterator _Self;

  //以下是迭代器设计的关键，访问容器的节点
  _Tp* _M_cur;//指向缓冲区当前的元素
  _Tp* _M_first;//指向缓冲区的头(起始地址)
  _Tp* _M_last;//指向缓冲区的尾(结束地址)
  _Map_pointer _M_node;//指向中控器的相应节点

  _Deque_iterator(_Tp* __x, _Map_pointer __y) 
    : _M_cur(__x), _M_first(*__y),
      _M_last(*__y + _S_buffer_size()), _M_node(__y) {}
  _Deque_iterator() : _M_cur(0), _M_first(0), _M_last(0), _M_node(0) {}
  _Deque_iterator(const iterator& __x)
    : _M_cur(__x._M_cur), _M_first(__x._M_first), 
      _M_last(__x._M_last), _M_node(__x._M_node) {}

  //****************************************************************************
  //*********************以下是迭代器_Deque_iterator的操作**********************
  //*    这些操作符的重载方便我们访问容器的内容
  //*    也是让deque从接口看来是维护连续线性空间的关键
  //****************************************************************************
  reference operator*() const { return *_M_cur; }//解除引用,返回当前元素
#ifndef __SGI_STL_NO_ARROW_OPERATOR
  pointer operator->() const { return _M_cur; }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */

  //返回两个迭代器之间的距离
  difference_type operator-(const _Self& __x) const {
    return difference_type(_S_buffer_size()) * (_M_node - __x._M_node - 1) +
      (_M_cur - _M_first) + (__x._M_last - __x._M_cur);
  }

  //前缀自增++操作符重载 
  _Self& operator++() {
    ++_M_cur;                    //普通自增操作，移至下一个元素
    if (_M_cur == _M_last) {   //若已达到缓冲区的尾部
      _M_set_node(_M_node + 1);//切换至下一缓冲区(节点)
      _M_cur = _M_first;      //的第一个元素
    }
    return *this;
  }
  //后缀自增++操作符重载
  //返回当前迭代器的一个副本
  _Self operator++(int)  {
    _Self __tmp = *this;//定义当前迭代器的一个副本
    ++*this;//这里前缀++不是普通的++操作，是上一步骤已经重载过的前缀++
    return __tmp;
  }

  //前缀自减--操作符重载
  //基本思想类似于前缀自增操作 
  _Self& operator--() {
    if (_M_cur == _M_first) {  //若是当前缓冲区的第一个元素
      _M_set_node(_M_node - 1);//切换到上一个缓冲区
      _M_cur = _M_last;          //的尾部(即最后一个元素的下一个位置)
    }
    --_M_cur;//普通的自减操作，移至前一个元素
    return *this;
  }
  //后缀自减--操作符重载
  //返回当前迭代器的副本
  _Self operator--(int) {
    _Self __tmp = *this;//定义一个副本
    --*this;            //迭代器自减操作
    return __tmp;
  }

  //以下实现随机存取，迭代器可以直接跳跃n个距离
  //将迭代器前移n个距离，当n负值时就为下面的operator-=操作
  _Self& operator+=(difference_type __n)
  {
    difference_type __offset = __n + (_M_cur - _M_first);//定义一个中间变量
    if (__offset >= 0 && __offset < difference_type(_S_buffer_size()))
        //若前移n个距离后，目标依然在同一个缓冲区
        //则直接前移n个距离
      _M_cur += __n;
    else {
        //若前移n个距离后，目标超出该缓冲区范围
        //__offset / difference_type(_S_buffer_size())计算向后移动多少个缓冲区
        //-difference_type((-__offset - 1) / _S_buffer_size()) - 1计算向前移动多少个缓冲区
      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;
  }

  //操作符+重载
  //返回操作之后的副本
  _Self operator+(difference_type __n) const
  {
    _Self __tmp = *this;
    //调用operator+=操作
    return __tmp += __n;
  }

  //利用operator+=操作实现
  _Self& operator-=(difference_type __n) { return *this += -__n; }
 
  _Self operator-(difference_type __n) const {
    _Self __tmp = *this;
    return __tmp -= __n;
  }

  //返回指定位置的元素，即实现随机存取
  //该函数调用operator+，operator*
  reference operator[](difference_type __n) const { return *(*this + __n); }

  bool operator==(const _Self& __x) const { return _M_cur == __x._M_cur; }
  bool operator!=(const _Self& __x) const { return !(*this == __x); }
  bool operator<(const _Self& __x) const {
    return (_M_node == __x._M_node) ? 
      (_M_cur < __x._M_cur) : (_M_node < __x._M_node);
  }
  bool operator>(const _Self& __x) const  { return __x < *this; }
  bool operator<=(const _Self& __x) const { return !(__x < *this); }
  bool operator>=(const _Self& __x) const { return !(*this < __x); }

  //调整到正确的缓冲区
  //切换到正确的元素位置
  void _M_set_node(_Map_pointer __new_node) {
    _M_node = __new_node;//指向新的节点
    _M_first = *__new_node;//指向新节点的头部
    _M_last = _M_first + difference_type(_S_buffer_size());//指向新节点的尾部
  }
};

//operator+迭代器向前移动n个位置
template <class _Tp, class _Ref, class _Ptr>
inline _Deque_iterator<_Tp, _Ref, _Ptr>
operator+(ptrdiff_t __n, const _Deque_iterator<_Tp, _Ref, _Ptr>& __x)
{
  return __x + __n;
}

#ifndef __STL_CLASS_PARTIAL_SPECIALIZATION

template <class _Tp, class _Ref, class _Ptr>
inline random_access_iterator_tag
iterator_category(const _Deque_iterator<_Tp,_Ref,_Ptr>&)
{
  return random_access_iterator_tag();
}

template <class _Tp, class _Ref, class _Ptr>
inline _Tp* value_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) { return 0; }

template <class _Tp, class _Ref, class _Ptr>
inline ptrdiff_t* distance_type(const _Deque_iterator<_Tp,_Ref,_Ptr>&) {
  return 0;
}

#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */

#ifdef __STL_USE_STD_ALLOCATORS

// Base class for ordinary allocators.
//这里只负责中控器节点内存管理
template <class _Tp, class _Alloc, bool __is_static>
class _Deque_alloc_base {
public:
  typedef typename _Alloc_traits<_Tp,_Alloc>::allocator_type allocator_type;
  allocator_type get_allocator() const { return _M_node_allocator; }

  _Deque_alloc_base(const allocator_type& __a)
    : _M_node_allocator(__a), _M_map_allocator(__a),
      _M_map(0), _M_map_size(0)
  {}
  
protected:
  typedef typename _Alloc_traits<_Tp*, _Alloc>::allocator_type
          _Map_allocator_type;

  allocator_type      _M_node_allocator;
  _Map_allocator_type _M_map_allocator;

  _Tp* _M_allocate_node() {
    return _M_node_allocator.allocate(__deque_buf_size(sizeof(_Tp)));
  }
  void _M_deallocate_node(_Tp* __p) {
    _M_node_allocator.deallocate(__p, __deque_buf_size(sizeof(_Tp)));
  }
  _Tp** _M_allocate_map(size_t __n) 
    { return _M_map_allocator.allocate(__n); }
  void _M_deallocate_map(_Tp** __p, size_t __n) 
    { _M_map_allocator.deallocate(__p, __n); }

  _Tp** _M_map; //指向中控器map
  size_t _M_map_size;//中控器map可容纳指针的个数
};

deque 迭代器中有的数据也就4个指针，因此如果sizeof的话应该大小是16。

迭代器中联系了缓存区中的位置，以及在map控制中心的位置。

deque的数据结构

deque中维护了指向map的指针，还维护了start和finish两个迭代器，分别指向第一个缓冲区的第一个元素，和最后一个缓冲区的最后一个元素。同是记住map大小，因为当map节点不足的时候，需要更新配置一个更大的一块map。

template <class _Tp, class _Alloc>
class _Deque_base
  : public _Deque_alloc_base<_Tp,_Alloc,
                              _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
{
public:
  typedef _Deque_alloc_base<_Tp,_Alloc,
                             _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
          _Base;
  typedef typename _Base::allocator_type allocator_type;
  typedef _Deque_iterator<_Tp,_Tp&,_Tp*>             iterator;
  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;

  //参数__num_elements表示缓冲区(节点)存储元素的个数
  _Deque_base(const allocator_type& __a, size_t __num_elements)
    : _Base(__a), _M_start(), _M_finish()
    { _M_initialize_map(__num_elements); }
  _Deque_base(const allocator_type& __a) 
    : _Base(__a), _M_start(), _M_finish() {}
  ~_Deque_base();    

protected:
  void _M_initialize_map(size_t);
  void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
  void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
  enum { _S_initial_map_size = 8 };//中控器map默认大小

protected:
  iterator _M_start;//指向第一个缓冲区的第一个元素
  iterator _M_finish;//指向最后一个缓冲区的最后一个元素的下一个位置
};

deque中有两个迭代器，还有一个map指针，还有一个size_type ，因此大小应该是40个字节。

template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_reallocate_map(size_type __nodes_to_add,
                                          bool __add_at_front)
{
  //map原始节点数
  size_type __old_num_nodes = _M_finish._M_node - _M_start._M_node + 1;
  //map新的节点数
  size_type __new_num_nodes = __old_num_nodes + __nodes_to_add;

  _Map_pointer __new_nstart;
  if (_M_map_size > 2 * __new_num_nodes) {//若map的大小比新节点数的两倍还大，则只需调整迭代器start和finish
    __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 {//否则需重新分配一个新的map空间
    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);
    //拷贝原始map的内容
    copy(_M_start._M_node, _M_finish._M_node + 1, __new_nstart);
    //释放原始map空间
    _M_deallocate_map(_M_map, _M_map_size);
    //更新map的起始地址和大小
    _M_map = __new_map;
    _M_map_size = __new_map_size;
  }

  //更新迭代器start和finish
  _M_start._M_set_node(__new_nstart);
  _M_finish._M_set_node(__new_nstart + __old_num_nodes - 1);
}

这个函数时用来设置map的相关内容。最少是管理8个节点，最多是所需节点的2倍。

当finish.cur == finish.last-1的时候，是需要一个新的缓冲空间，如果缓存空间还有的话就直接使用，如果没有了就需要换一块新的缓存空间。

由于会不停的增删元素，因此会导致deque的map会向一边偏狭，因此有时候就需要重新调整map。在不够用的时候，在进行重新申请空间之前进行判断是否是真的需要换空间，如果当前map空间 是大于 2 倍的被占用的实际空间，就进行调整，否则就进行新空间的分配。不过deque的重新配置要比vector简单很多，不用涉及到大量的元素移动，要拷贝的也仅仅是map中的指针而已，因此deque的生长要比vector简单一点 。

 void pop_back() {
    if (_M_finish._M_cur != _M_finish._M_first) {
      --_M_finish._M_cur;
      destroy(_M_finish._M_cur);
    }
    else
      _M_pop_back_aux();
  }

  void pop_front() {
    if (_M_start._M_cur != _M_start._M_last - 1) {
      destroy(_M_start._M_cur);
      ++_M_start._M_cur;
    }
    else 
      _M_pop_front_aux();
  }

添加元素的时候要考虑空间扩展的问题，那么当进行弹出元素的时候就要考虑空间收缩的问题。

当最后缓冲区只剩下一个元素了，那么弹出的时候要调整当前的指针，同时析构当前元素，然后进行缓冲区的释放工作。

当前面的缓冲区只有最后一个元素存在的时候，如果这个时候要将前面的元素给弹出，这个时候要进行前面缓冲区的释放工作。同时设置好当前迭代的指针，每次进行增加或者是删除的时候，都需要进行迭代器指向的重置工作。

// Called only if _M_finish._M_cur == _M_finish._M_first.
template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_pop_back_aux()
{
  _M_deallocate_node(_M_finish._M_first);
  _M_finish._M_set_node(_M_finish._M_node - 1);
  _M_finish._M_cur = _M_finish._M_last - 1;
  destroy(_M_finish._M_cur);
}
template <class _Tp, class _Alloc>
void deque<_Tp,_Alloc>::_M_pop_front_aux()
{
  destroy(_M_start._M_cur);
  _M_deallocate_node(_M_start._M_first);
  _M_start._M_set_node(_M_start._M_node + 1);
  _M_start._M_cur = _M_start._M_first;
} 

下面的clear函数是用来清除整个deque，deque的最初状态是只有一个缓冲区，因此clear之后的deque是没有任何元素，同时仅仅保留了一个缓冲区这样的状态。

首先释放头和尾意外的缓冲区，

如果还剩下两个缓冲区，就将头缓冲区保存下来，当然析构对象是在所难免的了。

如果仅剩下一个缓冲区，就仅仅进行对象的析构工作。

template <class _Tp, class _Alloc> 
void deque<_Tp,_Alloc>::clear()
{
  //首先清空缓冲区是满数据的节点
    for (_Map_pointer __node = _M_start._M_node + 1;
       __node < _M_finish._M_node;
       ++__node) {
    destroy(*__node, *__node + _S_buffer_size());
    _M_deallocate_node(*__node);
  }

 //清除缓冲区还存在可用空间的节点，即只存储部分数据
    if (_M_start._M_node != _M_finish._M_node) {
    destroy(_M_start._M_cur, _M_start._M_last);
    destroy(_M_finish._M_first, _M_finish._M_cur);
    _M_deallocate_node(_M_finish._M_first);
  }
  else
    destroy(_M_start._M_cur, _M_finish._M_cur);

  _M_finish = _M_start;//表示容器为空

接下来的例子是erase函数。

首先计算那个前面和后面部分那个元素少，那个元素少就移动那个方向的元素。这么考虑也是很自然的事情。

template <class _Tp, class _Alloc>
typename deque<_Tp,_Alloc>::iterator 
deque<_Tp,_Alloc>::erase(iterator __first, iterator __last)
{
  if (__first == _M_start && __last == _M_finish) {//若擦除整个容器内容
    clear();
    return _M_finish;
  }
  else {
    difference_type __n = __last - __first;
    difference_type __elems_before = __first - _M_start;
    if (__elems_before < difference_type((this->size() - __n) / 2)) {
      copy_backward(_M_start, __first, __last);
      iterator __new_start = _M_start + __n;
      destroy(_M_start, __new_start);
      _M_destroy_nodes(__new_start._M_node, _M_start._M_node);
      _M_start = __new_start;
    }
    else {
      copy(__last, _M_finish, __first);
      iterator __new_finish = _M_finish - __n;
      destroy(__new_finish, _M_finish);
      _M_destroy_nodes(__new_finish._M_node + 1, _M_finish._M_node + 1);
      _M_finish = __new_finish;
    }
    return _M_start + __elems_before;
  }
}

最后说的是插入工作，删除需要移动元素，同样，插入也需要移动元素，所以用的方法和erase是一样的，都需要判断前面还有后面那边的元素少就移动那边的元素，

当然有两种特殊情况，如果是在最前面，就直接调用push_front函数去处理，如果是在后面插入就直接调用push_back来进行，否则就进行判断。

记得要更新迭代器哦。

大概deque就这么多了，其实deque的抽象确实是很棒的，这些都是迭代器的功劳。