STL源码剖析之萃取（traist）机制

假设算法依赖于迭代器所指对象的类型，这就需要提取各个迭代器的特性（相应型别）。

对于函数参数及函数内声明局部变量，利用function template的参数推导(argument deducation)机制，相当于重载。

template 
void func_impl(T t, U u) {
    U temp;            // OK, we’ve got the type
                       // The rest work of func…
}
 
template 
void func(T t) {
    func_impl(t, *t); // forward the task to func_impl
}

对于函数返回值，使用内嵌型别声明(nested type),typedef T value_type;但如果不是class type就不能定义内嵌型别，比如原生指针就不是（比如int*）。

template 
struct MyIter {
    typedef T value_type; // A nested type declaration, important!!!
    T* ptr;
    MyIter(T* p = 0) : ptr(p) {}
    T& operator*() const { return *ptr; }
};

template 
typename I::value_type func(I iter) { return *iter; }

Solution： 再加一个间接层，把智能指针和原生指针统统的封装起来。在讨论之前，先要说明一下模板偏特化（template partial specialization）的含义。所谓的偏特化和模板的默认参数是完全不同的两件事情，前者指的是当参数为某一类特定类型的时候，采用特殊的设计，也就是说是“针对template参数更进一步的条件限制所设计出来的一个特化版本”；而默认参数则是当不提供某些参数的时候，使用的一个缺省。

Template  class C {} // 为所有类型为T*的参数而准备的特殊版本

现在来封装“迭代器封装的对象类型”

template 
struct iterator_traits {
    Typedef I::value_type value_type;
}
 
template 
struct iterator_traits {
    typedef T value_type;
};


template
struct iterator_traits {
    typedef T value_type;
}
 
template 
typename iterator_traits::value_type func(I ite) {
    return *ite;
}

template 
struct iterator_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;
}

Input Iterator(只读)        Output Iterator(只写)
     |                      |
     +-----------+----------+
                 |
          Forward Iterator
                 |
       Bidirectional Iterator
                 |
       Random Access Iterator

template 
struct iterator {
    typedef Category iterator_category;
    typedef T       value_type;
    typedef Distance difference_type;
    typedef Pointer  pointer;
    typedef Reference reference;
};

template 
struct MyIter : public std::iterator { … }