最常使用的5种迭代器的型别为 value_type、difference_type、pointer、reference、iterator_category。
如果想要自己开发的容器和STL进行适配，就需要定义上述5种类型
iteraor_traits 必须针对传入的型别为 pointer 或者 pointer-to-const设计偏特化版本

template <class I>
struct iteraor_traits{
    typedef typename I::iterator_category iterator_category;
    typedef typename I::value_type value_type;
    typedef typename I::difference_type difference_type;
    typedef typename I::pointer pointer;
    typedef typename I::reference reference;
};

value_type

迭代器所指对象的型别

difference_type

两个迭代器之间的距离，表示容器的最大容量([begin,end))
例：STL 的count() 返回的数值就是迭代器的 difference type

template <class I>
struct iteraor_traits{
    typedef typename I::iterator_category iterator_category;
    typedef typename I::value_type value_type;
    typedef typename I::difference_type difference_type;
    typedef typename I::pointer pointer;
    typedef typename I::reference reference;
};

template <class I,class T>
typename iteraor_traits<I>::difference_type //这一整行限定的是函数的回返型别
count (I first,I last,const T& value){
    typename iteraor_traits<I>::difference_type n = 0;
    for (;first != last;++first) {
        if (*first == value){
            ++n;
        }
    }
    return n;
}

针对相应型别differe type,traits 的如下两个(针对原生指针而写的)特化版本
使用C++内建的ptrdiff_t （定义在<cstddef>头文件）作为原生指针的difference type

//针对原生指针设计的偏特化版本
template <class T>
struct iteraor_traits<T*>{
    typedef ptrdiff_t difference_type;
};

//针对原生的pointer-to-const设计的偏特化版本
template <class T>
struct iteraor_traits<const T*>{
    typedef ptrdiff_t difference_type;
};

当我们需要的任何迭代器I的difference type，可以怎么写 typename iterator_traits<I>::difference_type

pointer

指针和引用之间的关系是非常密切的，传回一个左值，令他代表所指之物，也可以令其代表所指之物的地址，即可以通过传回一个指针，指向迭代器的所指之物

Item& operator*() const {return *ptr;}
Item* operator->() const {return ptr;}

//针对原生指针设计的偏特化版本
template <class T>
struct iteraor_traits<T*>{
    typedef T* pointer;
    typedef T& reference;
};

//针对原生的pointer-to-const设计的偏特化版本
template <class T>
struct iteraor_traits<const T*>{
    typedef const T* pointer;
    typedef const T& reference;
};

reference

从迭代器所指之物的内容是否允许改变的角度出发，迭代器分为两种：不允许改变所指对象的内容称为const int*pic
允许改变所指之物的内容称为mutable iterators ，例如int * pi；
对于mutable iterator进行提领操作的时候，得到的不是一个右值(右值不允许赋值操作)，应该是一个左值。

    int *pi = new int(5);
    const int* pci = new int(9);
    *pi = 7; //对mutable iterator进行提领操作的时候 得到的是左值，允许赋值
    *pci = 1; //这个操作是不允许的，pci是const iterator
    //提领pci得到的结果是一个 右值 不允许赋值

C++左值是通过reference的方式返回的
当p是mutable iterator时，其value type是T 那么*p型别不应该是T 应该是T&
当p是constant iterator时，其value type是const T 那么*p型别不应该是const T 应该是const T&

iterator_category

//针对原生指针设计 偏特化版本
template <class T>
struct iteraor_traits<T*>{
    //注意 原生指针是一种Random access iterator
    typedef random_access_iterator_tag iterator_category;
};

//针对原生指针 pointer-to-const 设计 偏特化版本
template <class T>
struct iteraor_traits<const T*>{
    //注意 原生指针pointer-to-const 是一种Random access iterator
    typedef random_access_iterator_tag iterator_category;
};

迭代器的分类( 根据移动特性和施行操作 )

Input iterator :不允许外界改变只读
output iterator：唯写
forward iterator：允许写入型算法 (例如 replace() ) 在这种迭代器形成的区间上进行读写操作
bidirectional iterator : 可以双向移动，可以逆向访问迭代器的区间(例如逆向拷贝某个范围内的元素)
random access iterator : 前四种仅仅具备一部分指针算数的能力(前三种支持operator++，第四种需要加上operator--)；第五种需要涵盖所有的只针的算数的能力，比如p+n p-n p[n] p1-p2 p1<p2

直线和箭头并不代表继承的关系，而是所谓的概念和强化的关系
例子使用advance函数举例，这个函数有两个参数，迭代器p和数值n，函数需要实现迭代器p累计前进n次
3个例子：input iterator、bidirectional iterator 、random access iterator
倒是没有针对forwarditerator设计的版本，因为这个和 inputiterator而设计的版本完全一致

template <class InputIterator,class Distance>
void advance_II(InputIterator& i,Distance n){
    //单向 逐一前进
    while (n--)
        ++i;
}

template <class BidirectionalIterator,class Distance>
void advance_BI(BidirectionalIterator& i,Distance n){
    //双向 逐一前进
    if(n >= 0){
        while (n--){
            ++i;
        }
    } else{
        while (n++){
            --i;
        }
    }
}

template <class RandomAccessIterator,class Distance>
void advance_RAI(RandomAccessIterator&i ,Distance n){
    //双向 跳跃前进
    i += n;
}

程序调用advance()的时候具体使用哪一个函数定义呢？如果选择advance_II（）对于randomaccess iterator而言缺乏效率，O(1)操作变成了O(N)操作
如果是advance_RAI（）则无法接受 Input Iterator 需要对上述三个函数进行合并

template <class InputIterator,class Distance>
void advance(InputIterator& i,Distance n){
    if (is_random_access_iterator(i)){
        advance_RAI(i,n);
    } else if (is_bidiractional_iterator(i)){
        advance_BI(i,n);
    } else{
        advance_II(i,n);
    }
}

在执行期间决定使用哪一个版本，会影响程序的执行的效率，最好在编译期间就确定程序执行的正确的版本，因此使用函数的重载是最好的方式

struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};

上述这些classes只能作为标记使用，不需要任何成员
加上第三个参数，让他们之间形成重载的关系

template <class InputIterator,class Distance>
void __advance(InputIterator& i,Distance n,input_iterator_tag){
    //单向 逐一前进
    while (n--)
        ++i;
}

//这是一个单纯的传递调用的函数(trivial forwarding function)
template <class ForwardIterator,class Distance>
inline void __advance(ForwardIterator&i, Distance n,
                      forward_iterator_tag){
    //单纯的进行传递调用 (forwarding)
    advance(i,n,input_iterator_tag());
}

template <class BidirectionalIterator,class Distance>
void advance_BI(BidirectionalIterator& i,Distance n,
                bidirectional_iterator_tag){
    //双向 逐一前进
    if(n >= 0){
        while (n--){
            ++i;
        }
    } else{
        while (n++){
            --i;
        }
    }
}

template <class RandomAccessIterator,class Distance>
void advance_RAI(RandomAccessIterator&i ,Distance n,
                 random_access_iterator_tag){
    //双向 跳跃前进
    i += n;
}

__advance()的第三个参数只声明了型别，但是并没有指定参数的名称，其主要的目的是为了激活重载机制，函数中根本不使用这个参数
还需要一个对外开放的上层控制接口，调用上述的各自重载的__advance() ，这一层只需要两个参数，当其准备将工作转移给上述的_advance()时才会自行加上第三个参数：迭代器的类型。
使用traits机制从所获得的迭代器中推导出其类型

template <class I>
struct iteraor_traits{
    typedef typename I::iterator_category iterator_category;
    typedef typename I::value_type value_type;
    typedef typename I::difference_type difference_type;
    typedef typename I::pointer pointer;
    typedef typename I::reference reference;
};

template <class InputIterator,class Distance>
inline void advance(InputIterator&i, Distance n){
    __advance(i,n,iteraor_traits<InputIterator>::iterator_category());
}

iteraor_traits<InputIterator>::iterator_category() 将产生一个暂时对象，就像int() 产生一个int暂时对象一样。
这个临时对象的型别应该隶属于前面所述的5个迭代器之一，然后根据这个迭代器的型别，编译器才决定调用哪一个_advance()重载函数

注意事项

迭代器其类型隶属于各个适配类型中最强化的那个。例如int* 既是random 、bidirectional、forward、input，那么其类型应该从属为random_access_iterator_tag
但是迭代器的参数需要按照最低阶的类型为其命名，比如advance（）函数，使用最低级的inputIterator为其命名

消除 “单纯传递调用的函数”

使用class定义迭代器的各种分类标签，不仅可以促进重载机制的成功运作，使得编译器得以正确执行重载决议，overloaded resolution
还可以通过继承不比再写 "单纯只做传递调用"的函数，即advance不需要写 Forwarditerator这个版本

仿真测试tag types继承关系所带来的影响

例子：使用distance举例子计算两个迭代器之间的距离

distance可以接受任何类型的迭代器，但是template型别参数设置为InputIterator，是为了遵循STL算法的命名规则，使用最低级的迭代器命名
考虑到继承关系，当客户端调用distance()函数输入的参数型别是 Output iterators、Bidirectional Iterators、ForwardIterator时，统统都会转化为Input Iterator版_distance函数
即存在继承关系的模型，仅仅实现首和尾即可，中间版本都会被隐式转化为首，尾巴调用专属的函数即可

std::iterator 保证

规范需要任何的迭代器都需要实现上述的五个内嵌的型别，从而方便traits进行类型的萃取，否则无法适配 STL的组件
STL提供了iterator class，新设计的迭代器需要继承自它，它不包含任何的成员，只是进行了型别的定义，因此继承它不会导致额外的负担

#include <memory>

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{};

//自行开发的迭代器需要继承 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;
};

//traits
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;
};

//针对原生指针(native pointer)设计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 T*                         pointer;
    typedef T&                         reference;
};

//函数的目的是为了 方便的决定某个迭代器的类型 (category)
template <class Iterator>
inline typename iterator_traits<Iterator>::iterator_category
iterator_category(const Iterator&){
    typedef typename iterator_traits<Iterator>::iterator_category 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*>(0);
}

//函数的目的是为了 方便的决定某个迭代器的类型 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*>(0);
}

//整组的distance函数
template <class InputIterator>
inline typename iterator_traits<InputIterator>::difference_type
__distance(InputIterator first,InputIterator last,
           input_iterator_tag){
    typename iterator_traits<InputIterator>::difference_type n = 0;
    while (first != last){
        ++first;
        ++n;
    }
    return n;
}

template <class RandomAccessIterator>
inline typename iterator_traits<RandomAccessIterator>::difference_type 
__distance(RandomAccessIterator first,RandomAccessIterator last,
           random_access_iterator_tag){
    return (last - first);
}

template <class InputIterator>
inline typename iterator_traits<InputIterator>::difference_type
distance(InputIterator first,InputIterator last){
    typedef typename iterator_traits<InputIterator>::iterator_category category;
    return (__distance(first,last,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>=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;
}

template<class InputIterator,class Distance>
inline void advance(InputIterator& i,Distance n){
    __advance(i,n,iterator_category(i));
}

STL源码剖析 5中迭代器型别

value_type

difference_type

pointer

reference

iterator_category

迭代器的分类( 根据移动特性和施行操作 )

注意事项

std::iterator 保证

猜你喜欢