STL源码剖析——iterators与trait编程#4 iterator源码

　　在前两节介绍了迭代器的五个相应类型，并讲述如何利用traits机制提取迭代器的类型，但始终是把iteartor_traits类分割开来讨论，这影响我们的理解，本节将给出iteator的部分源码，里面涵盖了整个iteartor_traits泛化版本、偏特化版本以及一些算法的完整代码。重新把先前讲的知识捋顺一下。

 //节选自SGI STL<stl_iterator.h>
 
 //五种迭代器类型，继承表示，越底层的基类越低级，越上层的子类越高级
 struct input_iterator_tag {};
 struct output_iterator_tag {};
 struct forward_iterator_tag : public input_iterator_tag {};
 struct bidirectional_iterator_tag : public forward_iterator_tag {};
 struct random_access_iterator_tag : public bidirectional_iterator_tag {};
 
 //要使自己设计的迭代器符合STL的规范，最好继承自下面的std::iterator
 template <class Category, class T, class Distance = ptrdiff_t,
     class Pointer = T*, class Reference = T&>
     struct iterator {
     typedef Category  iterator_category;
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;
 };
 
 //提取迭代器五个相应类型的榨汁机iterator_traits，可以看到迭代器其特性均来自迭代器本身，说明设计迭代器时候就应该考虑提供这五个相应类型。所以为了防止自己设计时有所遗漏，继承std::iterator是上策
 template <class Iterator>
 struct iterator_traits {
     typedef typename Iterator::iterator_category iterator_category;
     typedef typename Iterator::value_type        value_type;
     typedef typename Iterator::difference_type   difference_type;
     typedef typename Iterator::pointer           pointer;
     typedef typename Iterator::reference         reference;
 };
 //针对原生指针而设计的traits偏特化版本
 template <class T>
 struct iterator_traits<T*> {
     typedef random_access_iterator_tag iterator_category;
     typedef T                          value_type;
     typedef ptrdiff_t                  difference_type;
     typedef T*                         pointer;
     typedef T&                         reference;
 };
 //针对原生pointer-to-const而设计的traits偏特化版本
 template <class T>
 struct iterator_traits<const T*> {
     typedef random_access_iterator_tag iterator_category;
     typedef T                          value_type;
     typedef ptrdiff_t                  difference_type;
     typedef const T*                   pointer;
     typedef const T&                   reference;
 };
 //全局函数，这个函数可以很方便地决定某个迭代器的类型
 template <class Iterator>
 inline typename iterator_traits<Iterator>::iterator_category
 iterator_category(const Iterator&) {
     typedef typename iterator_traits<Iterator>::iterator_category category;    //使用traits机制提取其iterator category
     return category();
 }
 //全局函数，这个函数可以很方便地决定某个迭代器的distance type
 template <class Iterator>
 inline typename iterator_traits<Iterator>::difference_type*
 distance_type(const Iterator&) {
     return static_cast<typename iterator_traits<Iterator>::difference_type*>();
 }
 //全局函数，这个函数可以很方便地决定某个迭代器的value type
 template <class Iterator>
 inline typename iterator_traits<Iterator>::value_type*
 value_type(const Iterator&) {
     return static_cast<typename iterator_traits<Iterator>::value_type*>();
 }
 
 //整组distance函数，该函数有计算两迭代器距离的功能
 template <class InputIterator, class Distance>
 inline void __distance(InputIterator first, InputIterator last, Distance& n,
     input_iterator_tag) {        //如果是非随机迭代器，只能每次循环都要判断是否到达last迭代器
     while (first != last) { ++first; ++n; }
 }
 
 template <class RandomAccessIterator, class Distance>
 inline void __distance(RandomAccessIterator first, RandomAccessIterator last,
     Distance& n, random_access_iterator_tag) {    //随机迭代器，不用做两迭代器是否相同的比较，由于提供了operator-()，直接减法处理，速度比前者快
     n += last - first;
 }
 
 template <class InputIterator, class Distance>
 inline void distance(InputIterator first, InputIterator last, Distance& n) {
     __distance(first, last, n, iterator_category(first));    //使用上面提到的iterator_category()全局函数决定哪个迭代器类型
 }
 
 //以下是整组advance函数，该函数具有从某迭代器出发跳跃到指定距离位置的功能
 template <class InputIterator, class Distance>
 inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
     while (n--) ++i;    //使用非随机单向迭代器，只能逐次前进至指定位置
 }
 
 template <class BidirectionalIterator, class Distance>
 inline void __advance(BidirectionalIterator& i, Distance n,
     bidirectional_iterator_tag) {    //使用双向迭代器，可能往前或往后移动，但也是只能逐次移动至指定位置
     if (n >= )
         while (n--) ++i;
     else
         while (n++) --i;
 }
 
 template <class RandomAccessIterator, class Distance>
 inline void __advance(RandomAccessIterator& i, Distance n,
     random_access_iterator_tag) {    //随机迭代器，真正的跳跃
     i += n;
 }
 
 template <class InputIterator, class Distance>
 inline void advance(InputIterator& i, Distance n) {
     __advance(i, n, iterator_category(i));    //使用上面提到的iterator_category()全局函数决定哪个迭代器类型
 }