deque

      vector是单向开口的连续线性空间，deque是双向开口（在头尾分别做元素删除和插入操作）的连续线性空间。

     vector与deque的区别：

      1）deque允许在头部快速进行元素插入或删除操作,而vector只允许在尾部插入元素，头部只能查看不能插入或删除

       2）deque没有容量（capacity）的概念，因为它是动态地以分段连续空间组合而成的，随时可以增加一段新空间并链接起来。不会像vector那样“因旧空间不够而新配置一个更大空间，然后复制元素，再释放旧空间”。

    deque的迭代器也是Ramdon Access Iterator，但它的复杂度和vector是不一样的。一般尽可能选vector。

    对deque进行排序操行，为了最高效率，可将deque先复制到vector中，将vector排序后（用STL sort算法），再复制到deque。

deque的中控器

    deque由一段一段的定量连续空间构成。一旦有必要在deque的前端或尾端增加新空间，便配置一段连续空间，串接在整个deque的头或尾部。deque的最大任务，便是在这些分段的定量连续空间上，维护其整体连续的假象，并提供随机存取的接口。

      deque采用一块所谓的map（注意，不是STL的map容器）作为主控。这里所谓map是一小块连续空间，其中每个元素（此处称为一个节点，node）都是指针，指向另一段（较大的）连续线性空间，称为缓冲区。缓冲区才是deque的储存空间主体。SGI STL 允许我们指定缓冲区大小，默认值0表示将使用512 bytes 缓冲区。

template <class T, class Alloc = alloc, size_t BUFSIZ = 0>  
class deque {  
public:              //基本类型  
    typedef T value_type;  
    typedef value_type* pointer;  
    ...  
protected:          //内部类型  
    typedef pointer* map_pointer;  
protected:  
    map_pointer map; //指向map，map是一个T**，也就是一个指针，其所指之物又是指针  
    size_type map_size; //map内可以容纳多少指针  
};  

       deque是分段连续的，但在外面它又一直维护着整体连续的假象。我们先看看deque的数据结构：

 iterator start;               // 起始缓冲区  
  iterator finish;              // 最后一个缓冲区  
  // 指向map, map是一个连续的空间, 其每个元素都是一个指向缓冲区的指针  
  // 其模型见前面的__deque_iterator  
  map_pointer map;  
  size_type map_size;   // map容量,有多少个指针  

   如下是迭代器的结构：

 T* cur;       // 此迭代器所指之缓冲区中的现行元素  
  T* first;     // 此迭代器所指之缓冲区的头  
  T* last;      // 此迭代器所指之缓冲区的尾（含备用空间）  
  map_pointer node; //指向管控中心，也就是中控器里的节点，很重要！！ 

此外迭代器还得完成“整体连续”的假象，如下：

/* 
  迭代器内对各种指针运算都进行了重载， 
  所以各种指针运算如加、减、前进、后退等都不能直观视之。 
  最关键的是：一旦遇到缓冲区边缘，要特别小心， 
  视前进或后退而定，可能需要调用set_node()跳一个缓冲区 
  */  
  void set_node(map_pointer new_node)  
  {  
    node = new_node;  
    first = *new_node;  
    last = first + difference_type(buffer_size());  
  }  
};  


 self& operator++()  
  {  
    ++cur;       //切换到下一个元素  
    if (cur == last) {    //如果达到了缓冲区尾端 （“缓冲区”！！注意“last”与“fininsh”） 
      set_node(node + 1); //就切换至下一节点（也就是缓冲区）  
      cur = first;        //的第一个元素  
    }  
    return *this;  
  }  
  
  // 后缀自增  
  // 返回当前迭代器的一个副本, 并调用前缀自增运算符实现迭代器自身的自增  
  self operator++(int)  {  
    self tmp = *this;  
    ++*this;  
    return tmp;  
  }  
  
  // 前缀自减, 处理方式类似于前缀自增  
  // 如果当前迭代器指向元素是当前缓冲区的第一个元素  
  // 则将迭代器状态调整为前一个缓冲区的最后一个元素  
  self& operator--()  
  {  
    if (cur == first) {  
      set_node(node - 1);  
      cur = last;  
    }  
    --cur;  
    return *this;  
  }  
  
  self operator--(int)  
  {  
    self tmp = *this;  
    --*this;  
    return tmp;  
  }  
  
//实现随机存取，迭代器可以直接跳跃n个距离  
  self& operator+=(difference_type n)  
  {  
    difference_type offset = n + (cur - first);  
    if (offset >= 0 && offset < difference_type(buffer_size()))  
      cur += n; //目标位置在同一缓冲区内  
    else {  //目标位置不在同一缓冲区内  
      difference_type node_offset =  
        offset > 0 ? offset / difference_type(buffer_size())  
                   : -difference_type((-offset - 1) / buffer_size()) - 1;  
      set_node(node + node_offset);  //切换到正确的节点（缓冲区）  
      //切换到正确的元素  
      cur = first + (offset - node_offset * difference_type(buffer_size()));  
    }  
    return *this;  

deque 的内存管理

deque有自己专属的空间配置器，如下：

protected:                
  typedef pointer* map_pointer;  
//专属空间配置器，每次配置一个元素大小
  typedef simple_alloc<value_type, Alloc> data_allocator;  
//专属空间配置器，每次配置一个指针大小
  typedef simple_alloc<pointer, Alloc> map_allocator;

//构造函数
  deque(int n, const value_type& value)  
    : start(), finish(), map(0), map_size(0)  
  {  
    fill_initialize(n, value);  
  }  


template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::fill_initialize(size_type n,  
                                               const value_type& value)  
{  
  create_map_and_nodes(n); //把deque的结构都产生并安排好  
  map_pointer cur;  
  __STL_TRY {  
      //为每个节点的缓冲区设置初值  
    for (cur = start.node; cur < finish.node; ++cur)  
      uninitialized_fill(*cur, *cur + buffer_size(), value);  
    //最后一个缓冲区的设定不太相同  
    uninitialized_fill(finish.first, finish.cur, value);  
  }  
#       ifdef __STL_USE_EXCEPTIONS  
  catch(...) {  
    for (map_pointer n = start.node; n < cur; ++n)  
      destroy(*n, *n + buffer_size());  
    destroy_map_and_nodes();  
    throw;  
  }  
#       endif /* __STL_USE_EXCEPTIONS */  
}  

// 创建内部使用的map，负责安排产生并安排好deque的结构  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::create_map_and_nodes(size_type num_elements)  
{  
  // 需要的结点数 = （元素个数 / 每个缓冲区能容纳的元素数 + 1）  
  size_type num_nodes = num_elements / buffer_size() + 1;  
  
  // map要维护的结点, 这里最小的值为8, 见initial_map_size()  
  //最大为“所需节点数加2”，前后各预备一个，扩充时可用  
  map_size = max(initial_map_size(), num_nodes + 2);  
  //配置有map_size个节点的map  
  map = map_allocator::allocate(map_size);  
  
  // 将[nstart, nfinish)区间设置在map的中间,  
  // 这样就能保证前后增长而尽可能减少map的重新分配次数  
  map_pointer nstart = map + (map_size - num_nodes) / 2;  
  map_pointer nfinish = nstart + num_nodes - 1;  
  
  // 分配结点空间  
  map_pointer cur;  
  __STL_TRY {  
      //为map内的每个现用节点配置缓冲区。所有缓冲区加起来就是deque  
      //的可用空间（最后一个缓冲区可能留有一些富裕）  
    for (cur = nstart; cur <= nfinish; ++cur)  
      *cur = allocate_node();  
  }  
#     ifdef  __STL_USE_EXCEPTIONS  
  catch(...) {  
    for (map_pointer n = nstart; n < cur; ++n)  
      deallocate_node(*n);  
    map_allocator::deallocate(map, map_size);  
    throw;  
  }  
#     endif /* __STL_USE_EXCEPTIONS */  
  
  // 维护指针状态，为deque的两个迭代器start、end设置正确内容  
  start.set_node(nstart);  
  finish.set_node(nfinish);  
  start.cur = start.first;  
  finish.cur = finish.first + num_elements % buffer_size();  
}  

//析构函数
 ~deque()  
  {  
    destroy(start, finish);     // <stl_construct.h>  
    destroy_map_and_nodes();  
  }  

template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::destroy_map_and_nodes()  
{  
  for (map_pointer cur = start.node; cur <= finish.node; ++cur)  
    deallocate_node(*cur);  
  map_allocator::deallocate(map, map_size);  
}  

deque的元素操作：

push_back(),push_front(),pop_back(),pop_front()

 void push_back(const value_type& t)  
  {  
    // STL使用前闭后开的区间, 所以如果缓冲区还有一个以上的备用空间,  
    // 则直接在finish.cur上构造对象即可, 然后更新迭代器  
    if (finish.cur != finish.last - 1) {  
      construct(finish.cur, t);  
      ++finish.cur;  
    }  
    // 容量已满就要新申请内存了  
    else  
      push_back_aux(t);  
  }  

// 仅当finish.cur == finish.last - 1才调用  
// 即最后一个缓冲区只剩一个备用空间才调用  
// 先配置一块新缓冲区，并设置新元素内容，然后更改迭代器  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::push_back_aux(const value_type& t)  
{  
  value_type t_copy = t;  
  reserve_map_at_back(); //若符合某种条件则必须重换一个map  
  *(finish.node + 1) = allocate_node(); //配置一个新节点（缓冲区）  
  __STL_TRY {  
    construct(finish.cur, t_copy);  
    finish.set_node(finish.node + 1); //改变finish，令其指向新缓冲区  
    finish.cur = finish.first; //设定finish的状态  
  }  
  __STL_UNWIND(deallocate_node(*(finish.node + 1)));  
}    

  void push_front(const value_type& t)  
  {  
    if (start.cur != start.first) { //第一个缓冲区还有备用空间  
      construct(start.cur - 1, t);  //直接在备用空间上构造元素  
      --start.cur;  //调整第一缓冲区的使用状态  
    }   
    else  //第一缓冲区无备用空间  
      push_front_aux(t);  
  }  
  
//  start.cur == start.first.  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::push_front_aux(const value_type& t)  
{  
  value_type t_copy = t;  
  reserve_map_at_front();  
  *(start.node - 1) = allocate_node(); //若符合某条件则必须重换一个map  
  __STL_TRY {  
    start.set_node(start.node - 1); //配置一个新缓冲区  
    start.cur = start.last - 1;  
    construct(start.cur, t_copy);  
  }  
#     ifdef __STL_USE_EXCEPTIONS  
  catch(...) {  //commit or rollback：若非全部成功，就一个不留  
    start.set_node(start.node + 1);  
    start.cur = start.first;  
    deallocate_node(*(start.node - 1));  
    throw;  
  }  
#     endif /* __STL_USE_EXCEPTIONS */  
}  

  void pop_back()  
  {  
    if (finish.cur != finish.first) {  
        //如果最后一个缓冲区有一个或多个元素  
      --finish.cur; //调整指针，相当于排除最后元素  
      destroy(finish.cur); //将最后元素析构  
    }  
    else //最后缓冲区没元素  
      pop_back_aux();  //进行缓冲区的释放  
  }  
  
  //  finish.cur == finish.first.  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>:: pop_back_aux()  
{  
  deallocate_node(finish.first); //释放最后一个缓冲区  
  finish.set_node(finish.node - 1);//调整finish的状态，指向  
  finish.cur = finish.last - 1;    //上一个缓冲区的最后一个元素  
  destroy(finish.cur);  
} 
 
  //与pop_back()类似  
  void pop_front() {  
    if (start.cur != start.last - 1)  
    {  
      destroy(start.cur);  
      ++start.cur;  
    }  
    else  
      pop_front_aux();  
  }  

  template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::pop_front_aux()  
{  
  destroy(start.cur);  
  deallocate_node(start.first);  
  start.set_node(start.node + 1);  
  start.cur = start.first;  
}  

当前后端空间不足时要进行整治：

reverse_map_at_back(),reverse_map_at_front()

void reserve_map_at_back (size_type nodes_to_add = 1)  
  {  
    if (nodes_to_add + 1 > map_size - (finish.node - map))  
        //如果map尾端的节点备用空间不够  
        //符合以上条件则必须重换一个map（配置更大，拷贝原来的，释放原空间）  
      reallocate_map(nodes_to_add, false);  
  }  
  
  void reserve_map_at_front (size_type nodes_to_add = 1)  
  {  
    if (nodes_to_add > start.node - map)  
        //如果map前端的节点备用空间不够  
        //符合以上条件则必须重换一个map（配置更大，拷贝原来的，释放原空间）  
      reallocate_map(nodes_to_add, true);  
  }  

// 重新配置map, 不会对缓冲区进行操作, map维护的是指向缓冲区的指针  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::reallocate_map(size_type nodes_to_add,  
                                              bool add_at_front)  
{  
  size_type old_num_nodes = finish.node - start.node + 1;  
  size_type new_num_nodes = old_num_nodes + nodes_to_add;  
  
  map_pointer new_nstart;  
  if (map_size > 2 * new_num_nodes) {  
    new_nstart = map + (map_size - new_num_nodes) / 2  
                     + (add_at_front ? nodes_to_add : 0);  
    if (new_nstart < start.node)  
      copy(start.node, finish.node + 1, new_nstart);  
    else  
      copy_backward(start.node, finish.node + 1, new_nstart + old_num_nodes);  
  }  
  else {  
    size_type new_map_size = map_size + max(map_size, nodes_to_add) + 2;  
  
    map_pointer new_map = map_allocator::allocate(new_map_size);  
    new_nstart = new_map + (new_map_size - new_num_nodes) / 2  
                         + (add_at_front ? nodes_to_add : 0);  
    copy(start.node, finish.node + 1, new_nstart);  
    map_allocator::deallocate(map, map_size);  
  
    map = new_map;  
    map_size = new_map_size;  
  }  
  
  start.set_node(new_nstart);  
  finish.set_node(new_nstart + old_num_nodes - 1);  
}  

clear(),erase()

//该函数清除整个deque，deque初始状态（无任何元素）时，有一个  
//缓冲区，因此clear后恢复初始，要保留一个缓冲区  
template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::clear()  
{  
  // 以下针对头尾以外的每个缓冲区（它们是饱满的）  
  for (map_pointer node = start.node + 1; node < finish.node; ++node) {  
    //将缓冲区内所有元素析构   
    destroy(*node, *node + buffer_size());  
    //释放缓冲区内存  
    data_allocator::deallocate(*node, buffer_size());  
  }  
  
  // 至少有头尾两个缓冲区  
  if (start.node != finish.node) {  
    destroy(start.cur, start.last); //将头缓冲区目前的元素析构  
    destroy(finish.first, finish.cur); //将尾缓冲区目前元素析构  
    //!!!注意：以下释放尾缓冲区，头缓冲区保留  
    data_allocator::deallocate(finish.first, buffer_size());  
  }  
  // 析构所有元素, 但是不释放空间, 因为deque要满足这个前置条件  
  // 具体的细节见本文件开头'特性'  
  else  
    destroy(start.cur, finish.cur);  
  finish = start;  //调整状态  
}  

template <class T, class Alloc, size_t BufSize>  
deque<T, Alloc, BufSize>::iterator  
deque<T, Alloc, BufSize>::erase(iterator first, iterator last)  
{  
    //清楚的是整个deque，直接调用clear()  
  if (first == start && last == finish) {  
    clear();  
    return finish;  
  }  
  else {  
    difference_type n = last - first; //清除区间长度  
    difference_type elems_before = first - start; //清楚区间前方的元素  
  
    //判断清除区间前后哪个元素少  
    if (elems_before < (size() - n) / 2) { //如果前方元素少，则将前方元素  
      copy_backward(start, first, last);   //后移（覆盖清除区间）  
      iterator new_start = start + n;  //标记deque新起点  
      destroy(start, new_start); //移动完毕，将冗余元素析构  
      //将冗余缓冲区释放  
      for (map_pointer cur = start.node; cur < new_start.node; ++cur)  
        data_allocator::deallocate(*cur, buffer_size());  
      start = new_start;  //设定deque新起点  
    }  
    else { //清除区间后方元素少，向前移动后方元素（覆盖清除区）  
      copy(last, finish, first);  
      iterator new_finish = finish - n;  
      destroy(new_finish, finish);  
      for (map_pointer cur = new_finish.node + 1; cur <= finish.node; ++cur)  
        data_allocator::deallocate(*cur, buffer_size());  
      finish = new_finish;  
    }  
    return start + elems_before;  
  }  
}  

insert()

template <class T, class Alloc, size_t BufSize>  
void deque<T, Alloc, BufSize>::insert(iterator pos,  
                                      const_iterator first,  
                                      const_iterator last)  
{  
  size_type n = last - first;  
  if (pos.cur == start.cur) {  
    iterator new_start = reserve_elements_at_front(n);  
    __STL_TRY {  
      uninitialized_copy(first, last, new_start);  
      start = new_start;  
    }  
    __STL_UNWIND(destroy_nodes_at_front(new_start));  
  }  
  else if (pos.cur == finish.cur) {  
    iterator new_finish = reserve_elements_at_back(n);  
    __STL_TRY {  
      uninitialized_copy(first, last, finish);  
      finish = new_finish;  
    }  
    __STL_UNWIND(destroy_nodes_at_back(new_finish));  
  }  
  else  
    insert_aux(pos, first, last, n);  
}  


template <class T, class Alloc, size_t BufSize>  
typename deque<T, Alloc, BufSize>::iterator  
deque<T, Alloc, BufSize>::insert_aux(iterator pos, const value_type& x)  
{  
  difference_type index = pos - start; //插入点之前的元素个数  
  value_type x_copy = x;  
  
  if (index < size() / 2) {   //如果插入点前元素个数少  
    push_front(front()); //在最前端加入与第一个元素同值的元素  
    iterator front1 = start;  
    ++front1;  
    iterator front2 = front1;  
    ++front2;  
    pos = start + index;  
    iterator pos1 = pos;  
    ++pos1;  
    copy(front2, pos1, front1); //元素移动  
  }  
  else { //插入点后的元素个数较少  
    push_back(back());  //在尾部插入一个与最后一个元素同值的元素  
    iterator back1 = finish;  
    --back1;  
    iterator back2 = back1;  
    --back2;  
    pos = start + index;  
    copy_backward(pos, back2, back1); //元素移动  
  }  
  *pos = x_copy; //在插入点上设定新值  
  return pos;  
}