C++ 标准模板库（STL）_iterator—— Traits（侯捷老师）

Traits

1、产生背景

在实际应用中，迭代器是容器和算法之间的桥梁。将范型算法(find, count, find_if)用于某个容器中,最重要的是要给算法提供一个访问容器元素的工具，iterator就扮演着这个重要的角色。

例如，算法需要向迭代器请求请求容器的数据类型，访问数据进行的哪种策略等等，包括以下五种请求（class iterators）+两种请求（non-class iterators）：

2、定义

STL里面使用iterator_traits这个结构来专门**“萃取”**迭代器的特性，前面代码中提到的value_type就是迭代器的特性之一

2.1 iterator_traits中定义的class iterators

五种类型：value_type、difference_type、pointer、reference、iterator_category，任何开发者如果想将自己开发的容器与STL结合在一起，就一定要为自己开发的容器的迭代器定义这五种类型，这样都可以通过统一接口iterator_traits萃取出相应的类型

template<typename Category,
         typename T,
         typename Distance = ptrdiff_t,
         typename Pointer = T*,
         typename Reference = T&>
struct iterator
{
    typedef Category iterator_category;
    typedef T value_type;
    typedef Distance difference_type;
    typedef Pointer pointer;
    typedef Reference reference;
};

• 1、 class iterators：

  • value_type： value_type就是指迭代器所指对象的类型，例如，原生指针也是一种迭代器，对于原生指针int*，int即为指针所指对象的类型，也就是所谓的value_type。

  • difference type：于表示两个迭代器之间的距离的一个类型,也可以用来表示一个容器的最大的容量，因为对于连续空间的容器，头尾之间的距离就是最大容量

  • iterator_category iterator_category的作用是标识迭代器的移动特性和可以对迭代器执行的操作，从iterator_category上，可将迭代器分为Input Iterator、Output Iterator、Forward Iterator、Bidirectional Iterator、Random Access Iterator五类。

    • Input Iterator：只读(read only)
    • Output Iterator：只写(write only)
    • Forward Iterator：允许“写入型”算法在此迭代器所形成的区间上进行读写操作
    • Bidirectional Iterator：可双向移动的迭代器
    • Random Access Iterator：前四种迭代器都只供应一部分指针的算数能力(前三种支持operator++，第四种支持operator–)，第五种则涵盖所有指针的算数能力，包括p+n,p-n,p[n],p1-p2,p1

  • reference type：迭代器所指对象的类型的引用，reference_type一般用在迭代器的*运算符重载上，如果value_type是T，那么对应的reference_type就是T&；如果value_type是const T，那么对应的reference_type就是const T&。

  • pointer：指迭代器所指的对象，也就是相应的指针，对于指针来说，最常用的功能就是operator*和operator->两个运算符。因此，迭代器需要对这两个运算符进行相应的重载工作：

template <typename I, typename T>
typename iterator_traits<I>::difference_type count
(I first, I last, count T& value)
{
    typename iterator_traits<I>::difference_type n = 0;
    for (; first != last; first++)
      if (*first == value)
          ++n;

    return n;
}

int array[5] = {1, 2, 3, 4, 5};
int *ptr1 = array + 1;//指向2
int *ptr2 = array + 3;//指向4
ptrdiff_t distance = ptr2 - ptr1;//结果即为difference_type

2.1 iterator_traits中定义的non-class iterators

原生指针也是一种迭代器，原生指针并不是一种类类型。

• 1、non-class iterators（native pointer原生指针）
  • T*
  • const T*

3、内嵌类型声明

参考

3.1、以迭代器所指对象的类型声明局部变量

下面是一个以迭代器为模板形参的函数模板：

template<typename Iterator>
void func(Iterator iter)
{
    //函数体
}

假如现在算法中需要声明一个变量，而变量的类型是迭代器所指对象的类型，应该怎么处理呢？

template<typename Iterator>
void func(Iterator iter)
{
    *Iterator var;//这样定义变量可以吗？
}

上面的代码是不可以通过编译的，虽然C++支持sizeof()，但是并不支持typeof()，就算是用到RTTI性质中的typeid()，获取到的也仅仅是类型的名字，因此不能直接用来声明变量。此时可以利用函数模板的参数类型推导机制解决问题，例如：

template<typename Iterator, typename T>
void func_impl(Iterator iter, T t)
{
    T temp;//这里就解决了问题
    //这里做原本func()的工作
}
 
template<typename Iterator>
void func(Iterator iter)
{
    func_impl(iter, *iter);//func的工作全部都移到func_impl里面了
}
 
int main(int argc, const char *argv[])
{
    int i;
    func(&i);
}

函数func作为对外接口，实际的操作却由函数func_impl执行，通过函数func_impl的参数类型推导，获取到Iterator指向对象的类型T，从而解决了问题。

3.2、以迭代器所指对象的类型声明返回类型

template<typename Iterator>
(*Iterator) func(Iterator iter)
{
    //这样定义返回类型可以吗？
}

在这种情况下，模板的参数类型推导机制也无能为力了，因为它只能推导参数，并不能推导函数的返回类型。STL解决这种问题的办法就是内嵌类型声明，即在迭代器内部添加一种“特性”，通过这种“特性”，算法可以很容易地获知迭代器所指对象的类型，请看下面的代码：

template<typename T>
class Iterator
{
public:
    typedef T value_type;//内嵌类型声明
    Iterator(T *p = 0) : m_ptr(p) {}
    T& operator*() const { return *m_ptr;}
    //...
 
private:
    T *m_ptr;
};
 
template<typename Iterator>
typename Iterator::value_type  //以迭代器所指对象的类型作为返回类型，长度有点吓人！！！
func(Iterator iter)
{
    return *iter;
}
 
int main(int argc, const char *argv[])
{
    Iterator<int> iter(new int(10));
    cout<<func(iter)<<endl;  //输出：10
}

函数func()的返回类型前面必须加上关键词typename，因为T是一个template参数，编译器在编译实例化func之前，对T一无所知，就是说，编译器并不知道Iterator::value_type是一个类型，或者是一个静态成员函数，还是一个静态数据成员，关键词typename的作用在于告诉编译器这是一个类型，这样才能顺利通过编译。

4、value_type

typedef：迭代器中添加元素的类型

template <class T>
struct MyIter {
    typedef T value_type;
    T * ptr;
    MyIter(T * p = 0) : ptr (p) {};
    T& operator* () const { return *ptr;}
};

template <class I>
typename I::value_type //取出迭代器类中的类型
//用以设定返回变量类型，但是如果I是指针就会错误
get (I ite) {
    return *ite;
}

这个版本并不支持原生指针，然而就迭代器的行为而言，就是面向容器的指针，而正常的STL算法也是支持原生指针的，原生指针并不是一种类类型，它是无法定义内嵌类型的。

4.1、提取以及偏特化

如果直接使用typename I::value_type，算法就无法接收原生指针，因为原生指针根本就没有value_type这个内嵌类型，这种偏特化是针对可调用函数get的偏特化，假如get有100行代码，那么就会造成极大的视觉污染。

#include <iostream>
template <class T>
struct MyIter {
    typedef T value_type;
    T * ptr;
    MyIter(T * p = 0) : ptr (p) {};
    T& operator* () const { return *ptr;}
};

template <class I>
typename I::value_type //取出迭代器类中的类型
get (I ite) {
    std::cout << "class version" << std::endl;
    return *ite;
}

template <class I>
I get(I* ite) {
    std::cout << "pointer version" << std::endl;
    return *ite;
}

template <class I>
I get(const I* ite) {
    std::cout << "const pointer version" << std::endl;
    return *ite;
}

int main() {
    int i = 3;
    const int k = 3;
    MyIter<int> v(&i);
    std::cout << get(v) << std::endl;
    std::cout << get(&i) << std::endl;
    std::cout << get(&k) << std::endl;
    return 0;
}

利用一个中间层iterator_traits固定了get的形式，使得重复的代码大量减少，唯一要做的就是稍稍特化一下iterator_tartis使其支持pointer和const pointer

#include <iostream>

template <class T>
struct iterator_traits {
    typedef typename T::value_type value_type;
};

template <class T>
struct iterator_traits<T*> {//偏特化,指针类型
    typedef T value_type;
};

template <class T>
struct iterator_traits<const T*> {//偏特化，常量指针类型
    typedef T value_type;
};

template <class T>
struct MyIter {
    typedef T value_type;
    T * ptr;
    MyIter(T * p = 0) : ptr (p) {};
    T& operator* () const { return *ptr;}
};

template <class I>
typename iterator_traits<I>::value_type
get (I ite) {
    std::cout << "normal version" << std::endl;
    return *ite;
}

int main() {
    int i = 3;
    const int k = 3;
    MyIter<int> v(&i);
    std::cout << get(v) << std::endl;
    std::cout << get(&i) << std::endl;
    std::cout << get(&k) << std::endl;
    return 0;
}

通过定义内嵌类型，我们获得了知晓iterator所指元素类型的方法，通过traits技法，我们将函数模板对于原生指针和自定义iterator的定义都统一起来。

5、difference type

difference type用于表示两个迭代器之间的距离的一个类型,也可以用来表示一个容器的最大的容量，因为对于连续空间的容器，头尾之间的距离就是最大容量

例如count()就必须返回的类型就是迭代器的difference type

template<class I>
struct iterator_traits {
...
    typedef typename I::difference_type difference_type;
}

//原生指针
template<class I>
struct iterator_traits<T*> {
...
    typedef ptrdiff_t difference_type;
}

template<class I>
struct iterator_traits<const T*> {
...
    typedef ptrdiff_t difference_type;
}

6、迭代器部分源码

/**
 * 用于标记迭代器类型
 */
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 {};

/**
 * 用于traits出迭代其所指对象的型别
 */
template <class Iterator>
struct iterator_traits
{
  // 迭代器类型, STL提供五种迭代器
  typedef typename Iterator::iterator_category iterator_category;

  // 迭代器所指对象的型别
  // 如果想与STL算法兼容, 那么在类内需要提供value_type定义
  typedef typename Iterator::value_type        value_type;

  // 这个是用于处理两个迭代器间距离的类型
  typedef typename Iterator::difference_type   difference_type;

  // 直接指向对象的原生指针类型
  typedef typename Iterator::pointer           pointer;

  // 这个是对象的引用类型
  typedef typename Iterator::reference         reference;
};

/**
 * 针对指针提供特化版本
 */
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;
};
/**
 * 针对指向常对象的指针提供特化
 */
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;
  return category();
}
/**
 * 返回表示迭代器距离的类型
 */
template <class Iterator>
inline typename iterator_traits<Iterator>::difference_type*
distance_type(const Iterator&)
{
  return static_cast<typename iterator_traits<Iterator>::difference_type*>(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);
}

参考

1、https://www.jianshu.com/p/c6e566071fdf
2、https://blog.csdn.net/shudou/article/details/10270971
3、https://blog.csdn.net/terence1212/article/details/52287762
4、《STL源码剖析》