我们知道标准库中的容器有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 的逻辑结构，才能知道迭代器操作符的的具体操作步骤。