我们知道标准库中的容器有vector,list和deque。另外还有slist，只不过它不是标准容器。而谈到容器，我们不得不知道进行容器一切操作的利器---迭代器。而在了解迭代器之前，我们得先知道每个容器的结构，包括它的逻辑结构和物理结构。让我们先说说vector:
一、vector
我们先来看看vector容器内元素在内存中的布局：
其中的#0，#1...就是容器内的元素。从上图可以看出vector维护的是一个连续的线性空间，和数组是一样的。所以不论其元素为何种型别，普通指针就可以作为vector的迭代器！因为vector迭代器所需要的操作如operator*,operator->,operator++,operator+,operator-,operator+=,operator-=,普通指针天生就具备。查看vector的源码，我们可以看到vector的迭代器并没有另外定义为一个模版类，而是直接
typedef value_type* iterator。 更可以看出 vector
的迭代器就是一个普通指针。对于普通指针，我就不在多说。相信大家也早已理解。
二、list
还是先来看看list的结构：从list的名字我们就可以看出 list
的结构应该是一个链表，事实上他的结构确实是一个链表---一个环状双向链表。他的结构图如下：；
画的可能有点乱，但是如果你知道双链表的结构，你可以自行画出。上图的每个结点就是 list
容器中用来保存元素值的结构了。其中的#0,#1...就是容器的实际保存的元素值。而 list 的迭代器本身是一个模板类，我们看看 list
的迭代器设计：
template<class T, class Ref, class Ptr>
struct __list_iterator {
//定义了一些类型的别名
typedef __list_iterator<T, T&, T*> iterator;
typedef __list_iterator<T, const T&, const T*> const_iterator;
typedef __list_iterator<T, Ref, Ptr> self;typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef __list_node<T>* link_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;link_type node;
//构造函数
__list_iterator(link_type x) : node(x) {}
__list_iterator() {}
__list_iterator(const iterator& x) : node(x.node) {}//重载操作符
bool operator==(const self& x) const { return node == x.node; }
bool operator!=(const self& x) const { return node != x.node; }
reference operator*() const { return (*node).data; }#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */self& operator++() {
node = (link_type)((*node).next);
return *this;
}
self operator++(int) {
self tmp = *this;
++*this;
return tmp;
}
self& operator--() {
node = (link_type)((*node).prev);
return *this;
}
self operator--(int) {
self tmp = *this;
--*this;
return tmp;
}
};
这个迭代器的模板类其实并没有多少东西。只包括：
1.定义一些类型别名
2.定义一个 node 成员变量
3.必要的构造函数和重载了的操作符
其中真正起作用的是 node 成员变量，它是指向 list 链表结构的结点的普通指针， list 链表结点的结构定义代码如下：
template <class T>
struct __list_node {
typedef void* void_pointer;
void_pointer next;
void_pointer prev;
T data;
};
就是一般的结构体啦，不过这里是模板形式的。其中的 prev 和 next是双向链表必须的两个指针分别指向前一个结点和后一个结点。data
用来保存实际的值。可以看出，list 的迭代器只是封装了 list node 的指针
，并重载了迭代器应有的操作符而已。想想我们在用普通操作链表的时候，要想指向下一个结点，也就是实现指针的自增是怎么做的？是不是用 p =
p->next啊，只不过这里把他用++操作符代替了我们的操作，更加方便了而已！所以 list 的迭代器也挺简单。list 迭代器重载了 ==, !=,
*, ->, 前置++,后置++,前置--,后置--。没有重载 +,-,+=,-n，所以 list 的迭代器只是一个 Bidirectional
Iterator。而 vector 的迭代器是普通指针，它是 Random Access Iterator。
三、deque
我们知道 vector 是个单向开口的连续线性空间，而 deque 则是一种双向开口的连续线性空间。所以 vector
从尾端插入元素效率较高，而如果从头部插入，则效率奇差。deque 可以从两端插入，效率也很高。在介绍 deque 迭代器之前，我们先来了解一下 deque
的逻辑结构。deque 到底是什么样的一个结构、在内存中如何布局，才可以从两端插入且是连续线性空间呢？我还是先来张图，根据图我们再娓娓道来：
看到这个图，大家也许蒙了，第一反映是怎么这么复杂？跟 vector
内存布局比起来，确实很复杂。因为它并不是真正的连续线性空间，而是模拟的。看到图中标志的缓冲区(node-buffer)没，它才是用来存储 deque
容器元素的真正承担者。他们是一段段定量连续空间。其大小可以自己指定，默认是 512bytes。接下来我们看看 map
这个结构：它也是一个连续的线性空间，不过它保存的是指向每个缓冲区(node-buffer)首地址的指针。map 起着中央控制器的作用，所以我们称其为中控器。既然
deque 在内存中如此布局，那如何伪装成一个连续的线性空间呢？造成这个假象的任务全落到了迭代器的身上。我们来看看 deque
迭代器、中控器、缓冲区之间的相互关系：
为了更好的说明问题，我给出一个实际的例子。现在假设有一个 deque 有 20 个元素，每个缓冲区是 8
个元素大小。其结构如下图：
我们看到实例中有三个缓冲区(node-buffer),可以保存24个元素，而现在deque只有20个，所以还剩4个剩余空间(图中灰色部分)。map是中控器，我们可以看到其并没有满，而且起始位置也不是在
map 首地址，这都是为了能够实现在头尾两端进行插入。再看看 start 和 finish，他们分别是 deque 的 begin()和 end()
返回的迭代器。看完迭代器、中控器、缓冲区之间的关系，我们来看看 deque 迭代器的代码：
1 //确定缓冲区大小的函数
2 inline size_t __deque_buf_size(size_t n, size_t sz)
3 {
4 return n != 0 ? n : (sz < 512 ? size_t(512 / sz) : size_t(1));
5 }
6
7 template <class T, class Ref, class Ptr>
8 struct __deque_iterator {
9 //定义一些类型别名
10 typedef __deque_iterator<T, T&, T*> iterator;
11 typedef __deque_iterator<T, const T&, const T*> const_iterator;
12 static size_t buffer_size() {return __deque_buf_size(0, sizeof(T)); }
13
14 typedef random_access_iterator_tag iterator_category;
15 typedef T value_type;
16 typedef Ptr pointer;
17 typedef Ref reference;
18 typedef size_t size_type;
19 typedef ptrdiff_t difference_type;
20 typedef T** map_pointer;
21
22 typedef __deque_iterator self;
23
24 //图片中的几个指针
25 T* cur;
26 T* first;
27 T* last;
28 //中控器结点
29 map_pointer node;
30
31 //构造函数
32 __deque_iterator(T* x, map_pointer y)
33 : cur(x), first(*y), last(*y + buffer_size()), node(y) {}
34 __deque_iterator() : cur(0), first(0), last(0), node(0) {}
35 __deque_iterator(const iterator& x)
36 : cur(x.cur), first(x.first), last(x.last), node(x.node) {}
37
38 //以下全是重载
39 reference operator*() const { return *cur; }
40 pointer operator->() const { return &(operator*()); }
41 //注意这个操作符
42 difference_type operator-(const self& x) const {
43 return difference_type(buffer_size()) * (node - x.node - 1) +
44 (cur - first) + (x.last - x.cur);
45 }
46 //注意这个操作符
47 self& operator++() {
48 ++cur;
49 if (cur == last) {
50 set_node(node + 1);
51 cur = first;
52 }
53 return *this;
54 }
55 self operator++(int) {
56 self tmp = *this;
57 ++*this;
58 return tmp;
59 }
60
61 self& operator--() {
62 if (cur == first) {
63 set_node(node - 1);
64 cur = last;
65 }
66 --cur;
67 return *this;
68 }
69 self operator--(int) {
70 self tmp = *this;
71 --*this;
72 return tmp;
73 }
74 //注意这个操作符
75 self& operator+=(difference_type n) {
76 difference_type offset = n + (cur - first);
77 if (offset >= 0 && offset < difference_type(buffer_size()))
78 cur += n;
79 else {
80 difference_type node_offset =
81 offset > 0 ? offset / difference_type(buffer_size())
82 : -difference_type((-offset - 1) / buffer_size()) - 1;
83 set_node(node + node_offset);
84 cur = first + (offset - node_offset * difference_type(buffer_size()));
85 }
86 return *this;
87 }
88
89 self operator+(difference_type n) const {
90 self tmp = *this;
91 return tmp += n;
92 }
93
94 self& operator-=(difference_type n) { return *this += -n; }
95
96 self operator-(difference_type n) const {
97 self tmp = *this;
98 return tmp -= n;
99 }
100
101 reference operator[](difference_type n) const { return *(*this + n); }
102
103 bool operator==(const self& x) const { return cur == x.cur; }
104 bool operator!=(const self& x) const { return !(*this == x); }
105 bool operator<(const self& x) const {
106 return (node == x.node) ? (cur < x.cur) : (node < x.node);
107 }
108 //用来跳一个缓冲区
109 void set_node(map_pointer new_node) {
110 node = new_node;
111 first = *new_node;
112 last = first + difference_type(buffer_size());
113 }
114 };
代码中最重要的就是迭代器重载的那些操作符，有*,->,-,前置++,后置++,前置--,后置--,+=,+,-=,-,[],==,!=,<！可以看出
deque 的迭代器是一个 Random Access
Iterator。我们要注意的几个操作符是++,--,+=,-=,+,-，这些操作都涉及到指针的移动，而deque是伪连续线性空间，在到移动到一个缓冲区尾部时，应该要用函数set_node()跳到下一个缓冲区。也就是说，我们要处理好边界情况。deque
的迭代器有些复杂，关键我们要知道 deque 的逻辑结构，才能知道迭代器操作符的的具体操作步骤。