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;
}