deque是一个双向开口的容器，在头尾两端进行元素的插入跟删除操作都有理想的时间复杂度。
deque使用的是分段连续线性空间，它维护一个指针数组(T** map)，其中每个指针指向一块连续线性空间。
(map左右两边一般留有剩余空间，用于前后插入元素，具体下面可以看到其实现)
根据上图，可以了解到deque的迭代器的基本定义。
1 template <class T, class Ref, class Ptr, size_t BufSiz>
2 struct __deque_iterator {
3 // 基本型别的定义
4 typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
5 typedef random_access_iterator_tag iterator_category;
6 typedef T value_type;
7 typedef Ptr pointer;
8 typedef Ref reference;
9 typedef size_t size_type;
10 typedef ptrdiff_t difference_type;
11 typedef T** map_pointer;
12 typedef __deque_iterator self;
13
14 // 缓冲区的大小
15 tatic size_t buffer_size() { ... }
16
17 // 主要维护的三个指针
18 T* cur; // 指向当前元素
19 T* first; // 指向当前缓冲区的头
20 T* last; // 指向当前缓冲区的尾
21
22 map_pointer node; // 指向当前缓冲区在map中的位置
23 // ...
24 };
deque的实现基本都是依赖于其迭代器的实现(主要是各种操作符的重载)
1 // 用于跳到下一个缓冲区
2 void set_node(map_pointer new_node) {
3 node = new_node;
4 first = *new_node;
5 last = first + difference_type(buffer_size());
6 }
7
8 reference operator*() const { return *cur; }
9 pointer operator->() const { return &(operator*()); }
10
11 self& operator++() {
12 ++cur;
13 if (cur == last) { // 到达缓冲区尾端
14 set_node(node + 1);
15 cur = first;
16 }
17 return *this;
18 }
19
20 self& operator--() {
21 if (cur == first) { // 已到达缓冲区头端
22 set_node(node - 1);
23 cur = last;
24 }
25 --cur;
26 return *this;
27 }
28
29 // 迭代器之间的距离(相隔多少个元素)
30 difference_type operator-(const self& x) const {
31 return difference_type(buffer_size()) * (node - x.node - 1) +
32 (cur - first) + (x.last - x.cur);
33 }
该迭代器还重载了operator+=、operator+、operator-=、operator-(difference_type)等，
都是通过set_node()跟调整cur、first、last、node成员来实现。同时重载的operator[]使用operator+来进行随机存取。
1 self& operator+=(difference_type n) {
2 difference_type offset = n + (cur - first);
3 if (offset >= 0 && offset < difference_type(buffer_size()))
4 cur += n;
5 else {
6 // 目标在不同的缓冲区
7 difference_type node_offset =
8 offset > 0 ? offset / difference_type(buffer_size())
9 : -difference_type((-offset - 1) / buffer_size()) - 1;
10 // 跳到相应的缓冲区
11 set_node(node + node_offset);
12 // 调整cur指针
13 cur = first + (offset - node_offset * difference_type(buffer_size()));
14 }
15 return *this;
16 }
17
18 // 下面的都直接或间接的调用operator+=
19 self operator+(difference_type n) const {
20 self tmp = *this;
21 return tmp += n;
22 }
23
24 self& operator-=(difference_type n) { return *this += -n; }
25
26 self operator-(difference_type n) const {
27 self tmp = *this;
28 return tmp -= n;
29 }
30
31 reference operator[](difference_type n) const { return *(*this + n); }
有了__deque_iterator，deque的基本实现就比较简单了(主要维护start、finish这两个迭代器)
下面是deque的基本定义
1 template <class T, class Alloc = alloc, size_t BufSiz = 0>
2 class deque {
3 public:
4 typedef T value_type;
5 typedef value_type* pointer;
6 typedef size_t size_type;
7 typedef pointer* map_pointer;
8 public:
9 typedef __deque_iterator<T, T&, T*, BufSiz> iterator;
10 protected:
11 iterator start; // 第一个节点
12 iterator finish; // 最后一个结点
13
14 map_pointer map;
15 size_type map_size;
16 public:
17 iterator begin() { return start; }
18 iterator end() { return finish; }
19
20 reference operator[](size_type n) { return start[difference_type(n)]; } // 调用迭代器重载的operator[]
21
22 // ...
23 }
deque的constructor会调用create_map_and_nodes()来初始化map
1 // 每次配置一个元素大小的配置器
2 typedef simple_alloc<value_type, Alloc> data_allocator;
3 // 每次配置一个指针大小的配置器
4 typedef simple_alloc<pointer, Alloc> map_allocator;
5
6 template <class T, class Alloc, size_t BufSize>
7 void deque<T, Alloc, BufSize>::create_map_and_nodes(size_type num_elements) {
8 // 需要分配的结点数 如果为能整除 则多分配多一个结点
9 size_type num_nodes = num_elements / buffer_size() + 1;
10
11 // 分配结点内存 (前后预留一个 用于扩充)
12 map_size = max(initial_map_size(), num_nodes + 2);
13 map = map_allocator::allocate(map_size);
14
15 // 将需要分配缓冲区的结点放在map的中间
16 map_pointer nstart = map + (map_size - num_nodes) / 2;
17 map_pointer nfinish = nstart + num_nodes - 1;
18
19 map_pointer cur;
20 // 为了简化 去掉了异常处理的代码
21 for (cur = nstart; cur <= nfinish; ++cur)
22 *cur = allocate_node(); // 为每个结点分配缓冲区
23 }
24
25 // 设置start、finish指针
26 start.set_node(nstart);
27 finish.set_node(nfinish);
28 start.cur = start.first;
29 finish.cur = finish.first + num_elements % buffer_size();
30 }
下面就剩下插入跟删除元素的实现了，首先看看关于push_front()的操作的实现。
1 void push_front(const value_type& t) {
2 if (start.cur != start.first) { // 第一缓冲区还有容量
3 construct(start.cur - 1, t);
4 --start.cur;
5 }
6 else
7 push_front_aux(t);
8 }
9
10 // 如果第一缓冲区容量不足会调用这个函数来配置新的缓冲区
11 template <class T, class Alloc, size_t BufSize>
12 void deque<T, Alloc, BufSize>::push_front_aux(const value_type& t) {
13 value_type t_copy = t;
14 reserve_map_at_front(); // 可能导致map的重新整治
15 *(start.node - 1) = allocate_node();
16 start.set_node(start.node - 1);
17 start.cur = start.last - 1;
18 construct(start.cur, t_copy);
19 }
20
21 // 根据map前面为分配的结点数量来判断是否需要重新整治
22 void reserve_map_at_front (size_type nodes_to_add = 1) {
23 if (nodes_to_add > start.node - map)
24 reallocate_map(nodes_to_add, true);
25 }
上面留下的reallocate_map函数执行如下功能:
1.如果map中空闲指针足够多，则将已分配的结点移到map的中间。
2.否则重新分配一个map，将旧的map释放，把已分配的结点移到new_map的中间。
然后调整start跟finish迭代器。
然后是pop_front()的实现
1 void pop_front() {
2 if (start.cur != start.last - 1) {
3 destroy(start.cur);
4 ++start.cur;
5 }
6 else
7 pop_front_aux();
8 }
9
10 // 当前缓冲区只剩一个元素
11 template <class T, class Alloc, size_t BufSize>
12 void deque<T, Alloc, BufSize>::pop_front_aux() {
13 destroy(start.cur);
14 deallocate_node(start.first); // 释放该缓冲区
15 start.set_node(start.node + 1);
16 start.cur = start.first;
17 }
而push_back()跟pop_back()的实现跟上面的大同小异。
最后看看erase()跟insert()的实现
1 iterator erase(iterator pos) {
2 iterator next = pos;
3 ++next;
4 difference_type index = pos - start; // 迭代器的operator-
5 if (index < (size() >> 1)) { // 如果清除点之前的元素比较少
6 // 将清除点之前的所有元素后移一位 然后删除第一个元素
7 copy_backward(start, pos, next); // 利用了迭代器的operator--
8 pop_front();
9 }
10 else { // 如果清除点之后的元素比较少
11 // 将清除点之后的所有元素前移一位 然后删除最后一个元素
12 copy(next, finish, pos); // 利用了迭代器的operator++
13 pop_back();
14 }
15 return start + index;
16 }
1 iterator insert(iterator position, const value_type& x) {
2 if (position.cur == start.cur) {
3 // 插入位置为begin()
4 push_front(x);
5 return start;
6 }
7 else if (position.cur == finish.cur) {
8 // 插入位置为end()
9 push_back(x);
10 iterator tmp = finish;
11 --tmp;
12 return tmp;
13 }
14 else {
15 // 如果插入位置是在(begin(), end())
16 return insert_aux(position, x);
17 }
18 }
19
20 // insert_aux()跟erase()实现类似
21 // 调用copy()或者copy_backward()将元素前移或者后移
22 // 然后修改原来位置的值
来源：https://www.cnblogs.com/runnyu/p/6000368.html