STL源码剖析——迭代器概念和trait编程技巧

迭代器模式：提供一种方法，使之能够依序巡防某个聚合物（容器）所含的各个元素，而又无需暴露该聚合物的内部表达式。

STL的中心思想在于：将数据容器和算法分开，彼此独立设计，最后再以一帖胶着剂将它们撮合在一起。

template <typename T>
class List
{
public:
	void insert_front(T value);
	void insert_end(T value);
	void display(std::ostream &os = std::cout) const;
	//...
private:
	ListItem<T>* _end;
	ListItem<T>* _front;
	long _size;
};

template <typename T>
class ListItem
{
public:
	T value() const { return _value };
	ListItem* next() const{ return _next; }
	//...
private:
	T _value;
	ListItem* _next; //单向链表
};

template<class Item>
struct ListIter
{
	Item* ptr;

	ListIter(Item* p = 0) :ptr(p){}
	Item& operator*() const{ return *this; }
	Item* operator->() const { return ptr; }
	ListIter& operator++(){//前置运算符
		ptr = ptr->next;
		return *this;
	}
	ListIter operator++(int){//后置运算符
		ListIter tmp = *this;
		++*this;
		return tmp;
	}
	bool operator==(const ListIter& i) const{
		return ptr == i.ptr;
	}
	bool operator!=(const ListIter& i) const{
		return ptr != i.ptr;
	}
};

void main()
{
	List<int> mylist;
	for (int i = 0; i < 5; i++){
		mylist.insert_front(i);
		mylist.insert_end(i + 2);
	}
	mylist.display();
	List<ListItem<int>> begin(mylist.front());
	List<ListItem<int>> end;
	List<ListItem<int>> iter;
	iter = find(begin, end, 3);
}

由于find函数内以*iter ！=value来检查元素值，本例中，value为int，iter为ListItem<int>，所以还需要一个判断相等的重载函数。

template <class T>
struct MyIter{
	typedef T value_type; //内嵌型别声明
	T* ptr;
	MyIter(T* p = 0) :ptr(p){}
	T& operator*() const { return *ptr; }
	//...
};

template <class I>
typename I::value_type
func(I::value_type)
{
	return *ite;
}

偏特化的意义：

template <typename T>
class C{//...};//这个泛化版本允许（接受）T为任何型别

template<typename T>
class C<T*>{//...};//这个特化版本仅适用于"T为原生指针"的情况

traits:

template<class I>
struct iterator_traits{ //traits意为 特性
	typedef typename I::value_type value_type;
}

这个所谓的traits，其意义是，如果I定义有自己的value_type,那么通过这个traits的作用，萃取出来的value_type就是I::value_type。则fun()可以改写成:

template<class T>
struct iterator_traits<T*>{ //偏特化-迭代器是个原生指针
	typedef T value_type;
}

template <class I>
typename iterator_traits<I>::value_type
func(I ite)
{ return *ite; }于是，原生指针int*虽然不是一种class type，亦可以通过traits取其value type。

对于const要自己定义一个const版本的：

template<class T>
struct iterator_traits<const T*>{ //偏特化-当迭代器是个const指针时，萃取出来的是T，而非const T
	typedef T value_type;
}

最长用到的迭代器相应型别有5种：