STL源代码剖析-10 迭代器，type-traits (3)

在STL源代码剖析-03 stl_construct.h中我们己经简单的讨论过type traits技术了，里面提到了对象在construct 和 destory时“它们的第三个参数__false_type和__true_type都是一个空对象，它使用的是_type_traits来提取类型特性，再根据类型特性来判断应该调用哪一个版本，对于自己写的类我们也可以特化自己的_type_traits。说白了这玩意就是问“现在使用的这个类型调用它的析构函数有用么？没屁用的话就不用调用了。”在type_traits.h中，我们可以看它type traits的定义：

struct __true_type {
};

struct __false_type {
};

template <class _Tp>
struct __type_traits {
   typedef __true_type     this_dummy_member_must_be_first;

   typedef __false_type    has_trivial_default_constructor;
   typedef __false_type    has_trivial_copy_constructor;
   typedef __false_type    has_trivial_assignment_operator;
   typedef __false_type    has_trivial_destructor;
   typedef __false_type    is_POD_type;
};

__true_type和__false_type都是个空对象，这样不会浪费空间。用bool也能达到目地，但是bool变量不能够达到编译期绑定。__type_traits对所有的内置类型和指针都进行了特化，就好像如果我们需要复制char，那么OK，直接memcpy就OK了，但是如果不是POD类型，那么就只能一个一个构造了。当在STL里面使用我们自定义的类时，我们可以定义自己的特化__type_traits，这样就能让编译器选择比较高效的方法来操作自己的类。下面就是指针的偏特化版本：

template <class _Tp>
struct __type_traits<_Tp*> {
   typedef __true_type    has_trivial_default_constructor;
   typedef __true_type    has_trivial_copy_constructor;
   typedef __true_type    has_trivial_assignment_operator;
   typedef __true_type    has_trivial_destructor;
   typedef __true_type    is_POD_type;
};

----------------------------------邪恶的分割线-----------------------------------------
在STL里面的stl_iterator_base.h头文件里，用到了iterator traits技术的有两个函数，advance和distance。前面看到type traits在constuct和destory里的使用，现在来看看advance函数：

template <class _InputIter, class _Distance>
inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
  while (__n--) ++__i;
}

template <class _BidirectionalIterator, class _Distance>
inline void __advance(_BidirectionalIterator& __i, _Distance __n,
                      bidirectional_iterator_tag) {
  __STL_REQUIRES(_BidirectionalIterator, _BidirectionalIterator);
  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) {
  __STL_REQUIRES(_RandomAccessIterator, _RandomAccessIterator);
  __i += __n;
}

template <class _InputIterator, class _Distance>
inline void advance(_InputIterator& __i, _Distance __n) {
  __STL_REQUIRES(_InputIterator, _InputIterator);
  __advance(__i, __n, iterator_category(__i));
}

就在上面，advance函数的第一个参数是一个引用，即"值-结果"参数。它交给__advance来执行， iterator_category(__i)就是得到迭代器的类型了，上篇文章讲的那五种类型。

template <class _Tp, class _Distance>
inline input_iterator_tag
iterator_category(const input_iterator<_Tp, _Distance>&)
  { return input_iterator_tag(); }

inline output_iterator_tag iterator_category(const output_iterator&)
  { return output_iterator_tag(); }

template <class _Tp, class _Distance>
inline forward_iterator_tag
iterator_category(const forward_iterator<_Tp, _Distance>&)
  { return forward_iterator_tag(); }

template <class _Tp, class _Distance>
inline bidirectional_iterator_tag
iterator_category(const bidirectional_iterator<_Tp, _Distance>&)
  { return bidirectional_iterator_tag(); }

template <class _Tp, class _Distance>
inline random_access_iterator_tag
iterator_category(const random_access_iterator<_Tp, _Distance>&)
  { return random_access_iterator_tag(); }

然后就会选择最合适的__advance来执行了。如random_access_iterator_tag可以执行类似于指针的加减法，所以要向量向后一下子就可以了，就像要访问数组a哪个元素，直接a[x]就行了，而 input_iterator_tag则不行，它只能老老实实的一步一步走，就像list一样，要访问下一个元素必需先访问过前一个元素。
traits就是个好东西啊，比起if-else好多了。神奇的技术。