std::iterator 與 std::iterator_traits

std::iterator

std::iterator 是一個模板類，其聲明為：

template< 
    class Category,
    class T,
    class Distance = std::ptrdiff_t,
    class Pointer = T*,
    class Reference = T& 
> struct iterator;

std::iterator 是為簡化迭代器所需類型的定義而提供的基類。也就是說當我們寫一個模板類時，需要定義自己的迭代器 iterator，那么我們可以將 std::iterator 作為自定義迭代器的基類。
std::iterator 的模板參數：

• Category: 類型為 iterator_category,表示迭代器的種類，共有5類：
  
• T :類型為 value_type, 可以通過解除引用迭代器獲得的值的類型。 對於輸出迭代器，此類型應為 void。
• Distance: 類型為 difference_type, 一種可用於標識迭代器之間距離的類型。即兩個迭代器相減(若支持的話)的結果類型。
• Pointer: 類型為 pointer,定義指向迭代類型的指針（T）。即指向 T 類型的指針。
• Reference: 類型為 reference,定義迭代類型的引用（T）。即 T 的引用類型。
  例如自定義一個繼承自 std::iterator 的迭代器：

#include <algorithm>
#include <iterator>
using namespace std;

template<long FROM, long TO>
class Range
{
public:
	class Longiterator : public std::iterator<std::input_iterator_tag,  //@ iterator_category
		long, //@ value_type
		long, //@ difference_type
		const long*, //@ pointer
		long> //@ reference
	{
		long num_ = FROM;
	public:
		explicit Longiterator(long num = 0) : num_(num) {}
		Longiterator& operator++() { num_ = TO > FROM ? num_ + 1 : num_ - 1; return *this; }
		Longiterator operator++(int) { Longiterator retval = *this; ++(*this); return retval; }
		bool operator==(Longiterator other)const { return num_ == other.num_; }
		bool operator!=(Longiterator other)const { return !(*this == other); }
		reference operator*()const { return num_; }
	};

	Longiterator begin() { return Longiterator(FROM); }
	Longiterator end() { return Longiterator(TO > FROM ? TO + 1 : TO - 1); }
};

int main()
{
	auto range = Range<2, 10>();
	auto iter = std::find(range.begin(),range.end(),8);
	cout << *iter << endl;

	//@ range_based for 
	for (const auto& elem : range)
		cout << elem << " ";
	cout << endl;

	return 0;
}

std::iterator_traits

STL 中的算法與容器之間是通過迭代器架起的橋梁，算法需要知道迭代器的信息，以便采用最優算法。但是算法如何知道迭代器的詳細信息呢，此時就需要一個中間層：iterator_traits，它也是一個模板類，將 iteratoe進行了包裝，並使用模板局部特化技術:

//使用iterator提供的信息
template<typename Iterator>
struct iterator_traits
{
  typedef typename Iterator::iterator_category iterator_category;
  typedef typename Iterator::value_type        value_typep;
  typedef typename Iterator::difference_type   difference_type;
  typedef typename Iterator::pointer           pointer;
  typedef typename Iterator::reference         reference;
};

//@ 局部特化，c++內置指針。
template<typename 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;
};

//@ 局部特化，const c++內置指針。
template<typename T>
struct iterator_traits<const T *>
{
  typedef random_access_iterator_tag iterator_category;
  typedef T                          value_type; //@ 注意這里不是const T;如果是const T，算法拿到這個類型，用這個類型定義變量后，卻無法改變其值，那就沒有作用了，所以是T。
  typedef ptrdiff_t                  difference_type;
  typedef const T*                   pointer;
  typedef const T&                   reference;
};

例如:list類的size方法。

size_type size() const {
  size_type result = 0;
  distance(begin(), end(), result);
  return result;
  //return distance(begin(), end());    
}

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 {};

template <class InputIterator, class Distance>
inline void __distance(InputIterator first, InputIterator last, Distance& n, 
                       input_iterator_tag)
{
  while (first != last) { ++first; ++n; }
}

template <class RandomAccessIterator, class Distance>
inline void __distance(RandomAccessIterator first, RandomAccessIterator last, 
                       Distance& n, random_access_iterator_tag)
{
  n += last - first;
}

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

template <class InputIterator, class Distance>
inline void distance(InputIterator first, InputIterator last, Distance& n)
{
  __distance(first, last, n, iterator_category(first));
}

代碼1處，算法向 iterator_traits 要 iterator_category 的信息，如果 iterator 能提供，就使用 iterator 里的 iterator_category，如果 iterator 不能提供，就使用 iterator_traits 里的 iterator_category。得到iterator_category 后，就可以在編譯階段確定調用哪一個 __distance 方法了。