traits机制

traits -》特性萃取机

通过function template 参数推导机制，可以是实现迭代器类型的推导，然后如果需要推导返回值类型，那么参数推导机制就不可行了，这时候通过内嵌类型声明推导返回值类型。所以出现了traits机制。

STL将容器和算法分离，算法实现的过程中并不知道进来的迭代器是哪个容器的，所以加入一层traits封装，traits会榨取所有进入算法的迭代器的类型。

所以说traits就是在接口和实现中间的一层封装。

我们可以继续 针对 template 参数更进一步，所谓偏特化便提了出来，偏特化就是针对template参数更进一步的条件限制所设计出来的特化版本。

template <class T>
class C {...};            //这个泛化版本支持T为任何类型

template <class T>
class C<T*> {...};        //这个泛化版本仅适用于"T为原生指针的情况"
                          //T为原生指针便是T为任何类型的进一步条件限制

参考 STL 源码剖析这本书，实现如下代码，对traits 机制有了更深的理解。（其实就是多了一层封装，得到迭代器所有类型）

/*
*/
#include <iostream>
#include <vector>

//using namespace std;

struct intput_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public intput_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};


template <class Category, class T, class Distance = int, 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;
};

//偏特化版本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;
};

template <class Iterator>
typename iterator_traits<Iterator>::iterator_category iterator_category(const Iterator&)
{
	typedef typename iterator_traits<Iterator>::iterator_category category;
	return category();
}

template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type __distance(InputIterator first, InputIterator last, intput_iterator_tag k)
{
	typename iterator_traits<InputIterator>::difference_type n = 0;
	//while (first != last)
	//{
	//	++first;
	//	++n;
	//}
	std::cout << "intput_iterator_tag __distance!" << std::endl;
	return n;
}

template <class RandomAccessIterator>
typename iterator_traits<RandomAccessIterator>::difference_type __distance(RandomAccessIterator first, RandomAccessIterator last, random_access_iterator_tag k)
{
	typename iterator_traits<RandomAccessIterator>::difference_type n = 0;
	std::cout << "random_access_iterator_tag __distance!" << std::endl;
	return n;
}

template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last)
{
	typedef typename iterator_traits<InputIterator>::iterator_category category;
	return __distance(first, last, category());
}

template <class InputIterator, class Distance>
void __advance(InputIterator& i, Distance n, intput_iterator_tag k)
{
	while (n--) ++i;
}

template <class BidirectionalIterator, class Distance>
void __advance(BidirectionalIterator& i, Distance n, bidirectional_iterator_tag k)
{
	if (n > 0)
		while (n--)++i;
	else
		while (n++)--i;
}

template <class RandomAccessIterator, class Distance>
void __advance(RandomAccessIterator& i, Distance n, random_access_iterator_tag k)
{
	i += n;
}

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



int main()
{
	iterator<random_access_iterator_tag, int, int, int*, int&>rfirst, rlast;
	iterator_traits<iterator<random_access_iterator_tag, int, int, int*, int&>>::difference_type dis;
	dis = distance(rfirst, rlast);
}