template<class T> class iterator//表示迭代器针对泛型iterator_traits时的底层代码 { typedef T value_type; }; template<class Iterator> struct iterator_traits//泛化iterator_traits，作用多层间接性 { typedef typname Iterator::value_type value_type; }; template<class T> struct iterator_traits<T*>//特化iterator_traits，直接提取类型 { typedef T value_type; }; template<class T> struct iterator_traits<const T*>//特化iterator_traits，直接提取类型 { typedef T value_type; }; //typename iterator_traits<Iterator>调用的是泛化的或者特化的 template<class Iterator> typename iterator_traits<Iterator>::value_type fun(Iterator ite) { return *ite;//迭代器基本类型，以及有解引用功能 } //直接使用底层型别，如果是T*，则出问题，相当于value_type被解读为T* //同样用list<int>::iterator，则被解读为list<int>::iterator，而不会深度挖掘。 //显然只是适合于传递T，才能达到目的 template<class Iterator> typename Iterator::value_type fun(Iterator ite) { return *ite; } fun(list<int>::iterator ite);//显然是调用了iterator_traits模板 //typename iterator_traits<list<int>::iterator>::value_type //typedef typname list<int>::iterator::value_type value_type; //这就调用了list相应的迭代器中value_type，则为int。 //typedef typname list<int>::iterator::int value_type; //-------------------------------------------------------------上述是T类型，榨取--------------------------- //stl-iterator头文件 //具体的模板，可能需要的具体的5种型别不一样，有的模板直接可以确定下来。所以定义一个最高的母版为下 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; }; //例如<假象的>vector特化迭代器 template<class T> struct vector_iterator:public iterator<random_access_iterator_tag,T>{ typedef random_access_iterator_tag iterator_category;//vector模板可以确定 typedef T value_type; typedef size_type difference_type;//可以确定下来了 typedef Pointer pointer; typedef Reference reference; }; //基础榨取机模板类----泛化 template<class I> struct iterator_traits { typedef I::value_type value_type;//迭代器所指的类型 typedef I::difference_type difference_type;//迭代器距离 typedef I::pointer pointer; typedef I::reference reference; typedef I::iteratro_category iterator_category;//迭代器类型。 }; //特化版1 template<class T> struct iterator_traits<T*> { typedef T value_type;//迭代器所指的类型 typedef ptrdiff_t difference_type;//迭代器距离 typedef T* pointer; typedef T& reference; typedef random_access_iterator_tag iterator_category; }; //特化版2 template<class T> struct iterator_traits<const T*> { typedef T value_type;//迭代器所指的类型 typedef ptrdiff_t difference_type;//迭代器距离 typedef T* pointer; typedef T& reference; typedef random_access_iterator_tag iterator_category; }; //应用部分 template<class I> typename iterator_traits<I>::difference_type f(I);//榨取其中的ptrdiff_t //如果I传入的是类型为list<vector<int>>则，会先看list迭代器，取出其中元素为vector<int>，细调用 //vector的difference_type,此时就会调用int的difference_type,那此处就会有difference_type的类别名 template<class I> typename iterator_traits<I>::value_type f();//榨取其中的T template<class I> typename iterator_traits<I>::pointer f();//榨取其中的T* template<class I> typename iterator_traits<I>::reference f();//榨取其中的T& template<class I> typename iterator_traits<I>::iterator_category f();//榨取其中的random_access_iterator_tag //------------------------------下述，产生iterator_category的型别因素--------------------------------- //将5种类型迭代器，构造一个空类，其这样做目的是区分种类类型，而不需要任何数据成员。 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 {}; //输入迭代器---只读，单向 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 >= 0) 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; } //外口函数--客户端使用的，是2个参数的advance函数，是根据传入时的迭代器类型不同而定下采用哪个函数 template <class InputIterator, class Distance> inline void advance(InputIterator& i, Distance n) { __advance(i, n, iterator_category(i)); } //获取迭代器的 距离。----放回距离的指针，其值为0 template <class Iterator> inline typename iterator_traits<Iterator>::difference_type* distance_type(const Iterator&) { return static_cast<typename iterator_traits<Iterator>::difference_type*>(0); } //获取迭代器所指元素类型---放回元素类型指针，其值为0 template <class Iterator> inline typename iterator_traits<Iterator>::value_type* value_type(const Iterator&) { return static_cast<typename iterator_traits<Iterator>::value_type*>(0); } //函数获取，迭代器种类型别，放回种类型别对象，初始化后的 template <class Iterator> inline typename iterator_traits<Iterator>::iterator_category iterator_category(const Iterator&) { typedef typename iterator_traits<Iterator>::iterator_category category;//此处出来的最后是某个_tag类型 return category(); } //例如： advance(vector<int>::iterator,2);//通过传入的vector迭代器，则可以通过榨取机获得此类型为随机访问迭代器模型 //因为它会调用vector模板中的iterator_category,而它则某个_bag，则显然会被定义为随机访问迭代器。而不会是 //迭代器的I::iterator_category,故而和vector<list<int>>的迭代器类型应该是一致的。 //---------------------------------------------------//