vector,list,deque容器的迭代器简单介绍

　　我们知道标准库中的容器有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 迭代器的代码：

 //确定缓冲区大小的函数
 inline size_t __deque_buf_size(size_t n, size_t sz)
 {
   return n !=  ? n : (sz <  ? size_t( / sz) : size_t());
 }

 template <class T, class Ref, class Ptr>
 struct __deque_iterator {
   //定义一些类型别名
   typedef __deque_iterator<T, T&, T*>             iterator;
   typedef __deque_iterator<T, const T&, const T*> const_iterator;
   static size_t buffer_size() {return __deque_buf_size(, sizeof(T)); }

   typedef random_access_iterator_tag iterator_category;
   typedef T value_type;
   typedef Ptr pointer;
   typedef Ref reference;
   typedef size_t size_type;
   typedef ptrdiff_t difference_type;
   typedef T** map_pointer;

   typedef __deque_iterator self;

   //图片中的几个指针
   T* cur;
   T* first;
   T* last;
   //中控器结点
   map_pointer node;

   //构造函数
   __deque_iterator(T* x, map_pointer y)
     : cur(x), first(*y), last(*y + buffer_size()), node(y) {}
   __deque_iterator() : cur(), first(), last(), node() {}
   __deque_iterator(const iterator& x)
     : cur(x.cur), first(x.first), last(x.last), node(x.node) {}

   //以下全是重载
   reference operator*() const { return *cur; }
   pointer operator->() const { return &(operator*()); }
   //注意这个操作符
   difference_type operator-(const self& x) const {
     return difference_type(buffer_size()) * (node - x.node - ) +
       (cur - first) + (x.last - x.cur);
   }
   //注意这个操作符
   self& operator++() {
     ++cur;
     if (cur == last) {
       set_node(node + );
       cur = first;
     }
     return *this;
   }
   self operator++(int)  {
     self tmp = *this;
     ++*this;
     return tmp;
   }

   self& operator--() {
     if (cur == first) {
       set_node(node - );
       cur = last;
     }
     --cur;
     return *this;
   }
   self operator--(int) {
     self tmp = *this;
     --*this;
     return tmp;
   }
   //注意这个操作符
   self& operator+=(difference_type n) {
     difference_type offset = n + (cur - first);
     if (offset >=  && offset < difference_type(buffer_size()))
       cur += n;
     else {
       difference_type node_offset =
         offset >  ? offset / difference_type(buffer_size())
                    : -difference_type((-offset - ) / buffer_size()) - ;
       set_node(node + node_offset);
       cur = first + (offset - node_offset * difference_type(buffer_size()));
     }
     return *this;
   }

   self operator+(difference_type n) const {
     self tmp = *this;
     return tmp += n;
   }

   self& operator-=(difference_type n) { return *this += -n; }

   self operator-(difference_type n) const {
     self tmp = *this;
     return tmp -= n;
   }

   reference operator[](difference_type n) const { return *(*this + n); }

   bool operator==(const self& x) const { return cur == x.cur; }
   bool operator!=(const self& x) const { return !(*this == x); }
   bool operator<(const self& x) const {
     return (node == x.node) ? (cur < x.cur) : (node < x.node);
   }
   //用来跳一个缓冲区
   void set_node(map_pointer new_node) {
     node = new_node;
     first = *new_node;
     last = first + difference_type(buffer_size());
   }
 };

　　代码中最重要的就是迭代器重载的那些操作符，有*,->,-,前置++,后置++,前置--,后置--,+=,+,-=,-,[],==,!=,<！可以看出 deque 的迭代器是一个 Random Access Iterator。我们要注意的几个操作符是++,--,+=,-=,+,-，这些操作都涉及到指针的移动，而deque是伪连续线性空间，在到移动到一个缓冲区尾部时，应该要用函数set_node()跳到下一个缓冲区。也就是说，我们要处理好边界情况。deque 的迭代器有些复杂，关键我们要知道 deque 的逻辑结构，才能知道迭代器操作符的的具体操作步骤。