//    ITERATOR STUFF (from <iterator>)// ITERATOR TAGS (from <iterator>)
struct input_iterator_tag{    // identifying tag for input iterators
    };struct output_iterator_tag{    // identifying tag for output iterators
    };struct forward_iterator_tag: input_iterator_tag, output_iterator_tag{    // identifying tag for forward iterators  这些继承关系有有效的IS-A
    };struct bidirectional_iterator_tag: forward_iterator_tag{    // identifying tag for bidirectional iterators
    };struct random_access_iterator_tag: bidirectional_iterator_tag{    // identifying tag for random-access iterators};

// vector 容器 随机迭代器。list 容器 双向迭代器。template<...>
class vector{
public: class iterator{ public: typedef random_access_iterator_tag iterator_category;  　　　　 // 类型定义： vector<T>::iterator::iterator_category 就是 random_access_iterator_tag　　　　 // 即类型里面还有一个类型， 而这个类型仅仅是用来标识 这个类是属于哪个类型的。 };
};template<...>
class list{
public: class iterator{ public: typedef bidirectional_iterator_tag iterator_category; };
};

// advance 函数签名std::advance
template <class Iterator, class Distance>void advance (Iterator& it, Distance n);

// advance example
#include <iostream>     // std::cout
#include <iterator>     // std::advance
#include <list>         // std::listint main () {std::list<int> mylist;for (int i=0; i<10; i++) mylist.push_back (i*10);std::list<int>::iterator it = mylist.begin();std::advance (it,5); std::cout << "The sixth element in mylist is: " << *it << '\n';return 0;
}

// 即再封装一层，如果是用户自定义的，就直接获取内部定义的迭代器类型
// 如果是内置类型，就直接给设定成他所属的迭代器类型，用模版偏特化
// iterator_traits
template<typename IterT>
struct iterator_traits{ typedef typename IterT::iterator_category iterator_category; // 注意: 这里typename关键字 指示编译器解析 IterT::iterator_category 为一个类型
    ...
};template<typename IterT>        //template 偏特化，针对内置指针
struct iterator_traits<IterT*>{ typedef random_access_iterator_tag iterator_category;
};

template<typename IterT>
struct iterator_traits<const IterT*>{ typedef random_access_iterator_tag iterator_category;
};

// advance运行时确定使用哪种迭代器类型版本template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d)
{ if (typeid(typename std::iterator_traits<IterT>::iterator_category) == typeid(std::random_access_iterator_tag)) { iter += d;} else if(前向迭代器类型){ if (d < 0){throw std::out_of_range("Negative distance");} while (d--) ++iter; }else if(等等其他类型)...
} 

// advance编译器确定使用哪种迭代器类型版本

template<typename IterT, typename DistT>
void advance(IterT& iter, DistT d)
{ doAdvance(iter, d, typename std::iterator_traits<IterT>::iterator_category());
}
// 比如 双向迭代器的函数 。重载doAdvance，实现不同的迭代器类型的具体操作。
// 可以看到迭代器类型仅仅是个重载的作用,使得重载机制得以运行，都不需要变量名。
void doAdvance(IterT& iter, DistT d, std::bidirectional_iterator_tag)
{                                                                                                               if (d >= 0) {while (d--) ++iter;} else {while(d++) --iter;}
} 

template<class IterT>
struct iterator_traits{typedef typename IterT::iterator_category iterator_category;　　// 迭代器的类型所属typedef typename IterT::value_type value_type;   　　　　　　　　 // 迭代器所指对象的类型typedef typename IterT::difference_type difference_type;　　　　 // 迭代器之间的距离
 typedef typename IterT::pointer pointer;　　　　　　　　　　　　　　// 迭代器所指内容的地址typedef typename IterT::reference reference;　　　　　　　　　　　 // 迭代器所指之内容
};template<typename IterT>        //template 偏特化，针对内置指针
struct iterator_traits<IterT*>{ typedef random_access_iterator_tag iterator_category; typedef IterT value_type; typedef ptrdiff_t difference_type ; typedef IterT* pointer ; typedef IterT& reference ;
};

// TEMPLATE CLASS iterator
template<class _Category,class _Ty,class _Diff = ptrdiff_t,class _Pointer = _Ty *,class _Reference = _Ty&>struct iterator{    // base type for iterator classes
    typedef _Category iterator_category;typedef _Ty value_type;typedef _Diff difference_type;typedef _Pointer pointer;typedef _Reference reference;};