STL源码笔记（12）—序列式容器之deque（二）

再谈deque数据结构

我们知道deque是通过map管理很多个互相独立连续空间，由于对deque_iterator的特殊设计，使得在使用的时候就好像连续一样。有了deque_iterator的基础（例如重载的操作符等），对于我们实现容器的一些方法就十分方便了。与vector一样，deque也维护一个start，和finish两个迭代器，start指向容器中的一个元素，finish指向最后一个元素的后一个位置（前闭后开），从微观上讲，start指向map管理的第一个缓冲的第一个元素，finish管理最后一个缓冲的某一个元素（该元素是整个容器的最后一个元素）的后一个位置。
在STL源码中，这些指针由基类定义，并在子类中直接使用。

template <class _Tp, class _Alloc>
class _Deque_base {//基类
public:
  typedef _Deque_iterator<_Tp,_Tp&,_Tp*>             iterator;
  typedef _Deque_iterator<_Tp,const _Tp&,const _Tp*> const_iterator;
  //...
  //...
protected:
  iterator _M_start;//start指针
  iterator _M_finish;//finish指针
};

//-----------------------分割线-----------------
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class deque : protected _Deque_base<_Tp, _Alloc> {//子类
  typedef _Deque_base<_Tp, _Alloc> _Base;
public:                         // Iterators
  typedef typename _Base::iterator       iterator;
  typedef typename _Base::const_iterator const_iterator;

protected:
  using _Base::_M_map;//map 管理器
  using _Base::_M_map_size;
  using _Base::_M_start;//start指针
  using _Base::_M_finish;//finish指针

有了上述基础，在deque中定义的很多函数就可以轻松完成（很多操作都在deque_iterator中做了）

  iterator begin() { return _M_start; }//返回第一个元素的地址的左值
  iterator end() { return _M_finish; }//返回最后一个元素地址的后一个位置的左值
  const_iterator begin() const { return _M_start; }//const 版本
  const_iterator end() const { return _M_finish; }//const 版本
  //---------------------分割线-----------------------------------------------
  reference front() { return *_M_start; }//返回第一个元素的左值
  reference back() {//返回最后一元素的左值，（这里要把原迭代器向前移动一个位置）
    iterator __tmp = _M_finish;
    --__tmp;
    return *__tmp;
  }
  //注释：在书中提到为何不用*(_M_finish-1)来返回，因为对于deque_iterator来说，并没有重载这种类型的操作符，但事实上：存在

  _Self operator-(difference_type __n) const {
    _Self __tmp = *this;
    return __tmp -= __n;//直接使用重载的-=
  }

  const_reference front() const { return *_M_start; }//const 版本
  const_reference back() const {//const 版本
    const_iterator __tmp = _M_finish;
    --__tmp;
    return *__tmp;
  }
  //===================分割线=====================
  size_type size() const { return _M_finish - _M_start; }
  size_type max_size() const { return size_type(-1); }
  bool empty() const { return _M_finish == _M_start; }

deque的构造与内存管理

deque数据结构

书中给出4deque-test.cpp示例，提到缓冲区的大小为32bytes，这里在侯老师的代码中实际给出：

deque<int,alloc,8>ideq(20,9);

模板实参8表示缓冲区大小为8个元素，由于这里是int型（4字节）的，所以大小为8*sizeof(int)=32bytes。
而上述另一个模板实参就是空间配置器了。（不过书中这种写法说的是在G++环境下，切换到Ubuntu下也不行，可能是g++版本的原因）
在源码中定义空间配置器的方式与vector类似，都是通过simple_alloc进行转发，也是在deque的基类中进行定义，子类中使用。

template <class _Tp, class _Alloc>
class _Deque_base {//基类
//...
typedef _Alloc allocator_type;//空间分配器型别
typedef simple_alloc<_Tp, _Alloc>  _Node_alloc_type;
typedef simple_alloc<_Tp*, _Alloc> _Map_alloc_type;
_Tp* _M_allocate_node()//申请缓冲空间
    { return _Node_alloc_type::allocate(__deque_buf_size(sizeof(_Tp))); }
void _M_deallocate_node(_Tp* __p)//释放
    { _Node_alloc_type::deallocate(__p, __deque_buf_size(sizeof(_Tp))); }
_Tp** _M_allocate_map(size_t __n) //申请管理map的空间
    { return _Map_alloc_type::allocate(__n); }
void _M_deallocate_map(_Tp** __p, size_t __n) //释放
    { _Map_alloc_type::deallocate(__p, __n); }

protected:
  void _M_initialize_map(size_t);
  void _M_create_nodes(_Tp** __nstart, _Tp** __nfinish);
  void _M_destroy_nodes(_Tp** __nstart, _Tp** __nfinish);
//...
};

//=================>分割线<========================
template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >
class deque : protected _Deque_base<_Tp, _Alloc> {
  //...
  typedef _Deque_base<_Tp, _Alloc> _Base;
  typedef typename _Base::allocator_type allocator_type;
  allocator_type get_allocator() const { return _Base::get_allocator(); }
  using _Base::_M_initialize_map;
  using _Base::_M_create_nodes;
  using _Base::_M_destroy_nodes;

  using _Base::_M_allocate_node;
  using _Base::_M_deallocate_node;
  using _Base::_M_allocate_map;
  using _Base::_M_deallocate_map;
  //...
};

deque构造器详解

万事俱备，现在要将上述定义的指针啊，空间配置器什么的用起来，产生并安排好deque的结构——deque的constructor构造器：
与之前提到的很多东西一样，也是在基类中实现，构造函数除了初始化指针外，还要为deque“安排空间”，这里就需要用到空间配置器的东西了（上面的代码中早已做好了封装），书中提供create_map_and_nodes方法，在SGI STL源码中有这样一个函数：

//该函数的实现细节书中几乎一致，我在其中也做了一些注释
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;

    //一个map要管理多少个节点（想象一下就是指针数组的“行”）
    //最少是8个，最多是“所需要的节点加2”（预留）
    //enum { _S_initial_map_size = 8 };就体现了最少
  _M_map_size = max((size_t) _S_initial_map_size, __num_nodes + 2);
  _M_map = _M_allocate_map(_M_map_size);//分配空间，具有_M_map_size个节点

  //由于map会多2个节点的备用空间，这里两个指针指向map实际使用的首尾位置
  //也就是说，在首部多一个空闲节点，尾部多一个空闲节点
  _Tp** __nstart = _M_map + (_M_map_size - __num_nodes) / 2;
  _Tp** __nfinish = __nstart + __num_nodes;//这里在侯老师的书中还要减1（小细节，就是区间取闭区间和开区间的区别）

    /*
    STL_TRY
    STL_UNWIND
    就是实现try catch的功能
    */


  __STL_TRY {
      //为现用的（不包含备用的）节点配置缓冲区。
    _M_create_nodes(__nstart, __nfinish);//因为[__nstart,__nfinish)正是现用的区间嘛
  }
  __STL_UNWIND((_M_deallocate_map(_M_map, _M_map_size), 
                _M_map = 0, _M_map_size = 0));//try catch block如果不成功则一个都不留
    //以下配置迭代器（deque_iterator）以及迭代器中访问数据和管理缓冲区的指针
  _M_start._M_set_node(__nstart);//设置_M_start迭代器中的三个指针（管理缓冲区的节点地址，缓冲区的起点，缓冲区的终点）
  _M_finish._M_set_node(__nfinish - 1);//设置_M_finish迭代器中的三个指针
  _M_start._M_cur = _M_start._M_first;//设置指向当前元素值指针
  _M_finish._M_cur = _M_finish._M_first +
               __num_elements % __deque_buf_size(sizeof(_Tp));//设置指向最后一个元素元素指针
}

//====================>分割线<=====================
template <class _Tp, class _Alloc>
void _Deque_base<_Tp,_Alloc>::_M_create_nodes(_Tp** __nstart, _Tp** __nfinish)
{
  _Tp** __cur;
  __STL_TRY {
    for (__cur = __nstart; __cur < __nfinish; ++__cur)//侯书中__cur<=__nfinish
      *__cur = _M_allocate_node();//分配缓冲区，大小为 512/sizeof(T);T为型别
      //就是为每个map节点指针分配固定大小的缓冲区
  }
  __STL_UNWIND(_M_destroy_nodes(__nstart, __cur));//如果不成功则一个都不留（其实就是try catch block）
}

deque空间管理

其实就是由于Deque双向开口的特性，提供push_back()和push_front()两个操作，又由于这里deque实际上是由多个缓冲区和中控map来模拟连续空间，所以在添加构造元素的时要考虑当前缓冲区是否还够用，如果不够用了就得将中控map的节点指针向后（push_back）或者向前（push_front）挪动一小格，当然若连中控map也没有足够的节点来扩充了，还需要重新整治一下map。

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);//当前缓冲区空间不足，需要map挪一个节点。
  }

// Called only if _M_finish._M_cur == _M_finish._M_last - 1.
//缓冲被填满
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();//这个用来判断是否需要扩充map
  *(_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 push_front(const value_type& __t) {
    if (_M_start._M_cur != _M_start._M_first) {//当前缓冲足够
      construct(_M_start._M_cur - 1, __t);//直接往前构造
      --_M_start._M_cur;//更新指针
    }
    else
      _M_push_front_aux(__t);//需要往前挪动一个指针
  }
template <class _Tp, class _Alloc>
void  deque<_Tp,_Alloc>::_M_push_front_aux(const value_type& __t)
{
  value_type __t_copy = __t;
  _M_reserve_map_at_front();
  *(_M_start._M_node - 1) = _M_allocate_node();//先在前一个map节点处构造缓冲区
  __STL_TRY {
    _M_start._M_set_node(_M_start._M_node - 1);//设置新的节点
    _M_start._M_cur = _M_start._M_last - 1;//设置新的指针
    construct(_M_start._M_cur, __t_copy);//构造新节点
  }
  __STL_UNWIND((++_M_start, _M_deallocate_node(*(_M_start._M_node - 1))));
} 

上述有两个关键操作（实际是一个效果），就是扩充map节点。_M_reserve_map_at_front()&_M_reserve_map_at_back()而里面的实际操作却是由_M_reallocate_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))
    //map尾端节点备用空间不够
      _M_reallocate_map(__nodes_to_add, false);//配置更大的，拷贝，释放原来的
  }

当然对应的又pop_back()和pop_front()与在前端和后端插入类似，这里必须要判断是否需要释放整个缓冲区。

除了在首尾插入删除元素，deque还有一些常见的方法比如clear()、erase()、insert()等

//clear()
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()删除单个元素的版本
iterator erase(iterator __pos) {
    iterator __next = __pos;
    ++__next;
    difference_type __index = __pos - _M_start;//清除点之前的元素个数
    if (size_type(__index) < (this->size() >> 1)) {如果清除点之前的元素比较少
      copy_backward(_M_start, __pos, __next);//从后往前复制（此时待删除元素已经被覆盖）
      pop_front();//弹出第一个冗余元素
    }
    else {
      copy(__next, _M_finish, __pos);//从前往后复制
      pop_back();//待删除元素已经被覆盖
    }
    return _M_start + __index;//返回删除位置
  }

//============>>分割线<<========================

//earse()迭代器版本
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);//把前方元素拷贝到待删除区间的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;
  }
}

iterator insert(iterator position, const value_type& __x) {
    if (position._M_cur == _M_start._M_cur) {//如果插入点在最前端
      push_front(__x);//直接push_front()
      return _M_start;
    }
    else if (position._M_cur == _M_finish._M_cur) {//插入点最后端
      push_back(__x);//直接push_back()
      iterator __tmp = _M_finish;
      --__tmp;
      return __tmp;
    }
    else {
      return _M_insert_aux(position, __x);
    }
  }
//===========>>分割线<<=====================
template <class _Tp, class _Alloc>
typename deque<_Tp, _Alloc>::iterator
deque<_Tp,_Alloc>::_M_insert_aux(iterator __pos, const value_type& __x)
{
  difference_type __index = __pos - _M_start;//插入点之前的元素个数
  value_type __x_copy = __x;
  if (size_type(__index) < this->size() / 2) {//比较少
    push_front(front());//在最前端先插入一个元素
    iterator __front1 = _M_start;//标记
    ++__front1;
    iterator __front2 = __front1;
    ++__front2;
    __pos = _M_start + __index;
    iterator __pos1 = __pos;
    ++__pos1;
    copy(__front2, __pos1, __front1);//元素移动，实际是把冗余的首元素覆盖
  }
  else {//比较多
    push_back(back());
    iterator __back1 = _M_finish;
    --__back1;
    iterator __back2 = __back1;
    --__back2;
    __pos = _M_start + __index;
    copy_backward(__pos, __back2, __back1);
  }
  *__pos = __x_copy;//将多出来的位置赋值
  return __pos;
}