STL iterator traitor

迭代器的型别（associated types）是泛型编程中经常用到的一种技术。由于C++是一种弱类型语言，不支持typeof()。 虽然可以用RTTI中的typeid()， 获得的也只是型别的名称，不能用于声明变量。

解决方法可以用模板函数的参数推倒(argument deducation)

#include<iostream>
using namespace std;

template<class I, class T>
void func_impl(I iter, T t)
{
    T tmp;
    tmp = *iter;
    cout<<tmp<<endl;
    //do something ...
}

template<class I>
void func(I iter)
{
    func_impl(iter, *iter);
}

int main()
{
    int i = 10;
    func(&i);
}

但是，迭代器的型别不一定是指迭代器自身的类型。 因此，上述方法并不能解决所有问题。

可以使用内嵌声明

#include<iostream>
#include<string>
#include<vector>
using namespace std;

template<class T>
struct MyIter {
    typedef T value_type;
    T* ptr;
    MyIter(T* p): ptr(p) {}
    T& operator* () const { return *ptr; }
};
template<class T>
typename my_iterator_traits<T>::value_type
func(T iter)
{ return *iter; }

int main()
{
    MyIter<int> iter(new int(10));
}

但是，并不是所有的迭代器都是class类型的。对于指针，上述方法不能起作用。因为我们无法定义他的class type。

这是就需要用偏特化(Partial Specialization)

#include<iostream>
#include<string>
#include<vector>
using namespace std;

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

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

template<class T>
struct my_iterator_traits<T*>{
    typedef T value_type;
};

template<class T>
typename my_iterator_traits<T>::value_type
func(T iter)
{ return *iter; }

int main()
{
    MyIter<int> iter(new int(10));
    int p = 16;
    cout<<func(&p)<<endl;
}