迭代器模式:提供一种方法,使之能够依序巡防某个聚合物(容器)所含的各个元素,而又无需暴露该聚合物的内部表达式。
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种: