iterator和iterator_traits

 

   跟据侯捷的《STL源码剖析》一书中提到的《Design Patterns》一书中关于iterator模式定义：提供一种方法，使之能够依序寻访某个聚合物（容器）所含的各个元素，而又无需暴露该聚合物的内部表达方式。

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

  迭代器可以看作是一种smart pointer，故要进行内容提领和成员访问，关键的工作就是对operator*和operator->进行重载

//忽略模板类定义
T &operator*()const  {return *pointee;}  //其中T作为模板参数
T* operator->() const{return  pointee;} //pointee作为已定义成员

  当然iterator的设计中有一条关键的地方就是封装和隐藏，在此不提。

  为了引出STL设计的关键部分——Traits,需提到一个“相应型别”，也就是迭代其所指之物的类型。

  在c++中只有sizeof()和RTTI中的typeid()，前者只能判断出类型大小，无法进行类型确定，后者由于得到的只是一种别名（vs环境下为全程，MinGW下只是开头字母例如“int”中的‘i’。）况且后者属于运行期判断，不仅需要virutal而且判断期靠后因此不能拿来使用。

  我们在这里需要的并不是输出一个类型的名称，而是在调用过程中间接使用，将其隐藏起来。因此使用模板的类型推断是个不错的做法。

  迭代器相应型别最常用的有五种，分别是value_type,difference_type,reference,pointer,iterator_category。

  这里我们为了下面的Iterator_Traits技术需要提到一下模板偏特化问题。

例如：

template<typename T>
struct test
{
typedef  T    value_type;
T *pointer;
};
template<typename T>         //偏特化
struct test<T*>
{
typedef T value_type;
｝　　　　 

 偏特化的定义：针对任何template参数更进一步的条件限制所设计出来的一个特化版本。

 我们需要考虑的偏特化情形有如下情况：

 1.原始指针

 2 .const T * 

 之所以进行以下两种特化，主要愿意是1.原始指针无法进行内置型别的定义，也就是说无法进行typedef操作，故对以后的过滤会造成很大的麻烦，而且原始指针不能够被忽略。2.对于const T*来说，不能够被轻易修改，而且如果不另外考虑，也会造成不必要的麻烦。

可对照一下代码

//原模板
template<typename T>
struct test
{
 typedef  T  value_type；
};

//原始指针特化
template<typename T>
struct test<T*>
{
typedef T value_type;
};

//const pointer
template<typename T>
struct test<const T*>
{
typedef T value_type;
};

  这样，我们不管是调用哪个，都会有一个value_type，而这个value_type到底是何方神圣，已经被我们隐藏起来了。

  我们可以依照上述例子描述difference_type,pointer,reference。但是difference_type可以typedef库中的ptrdiff_t，来实现。

  至此，我们只剩下了iterator_category这一个类型了。

  iterator_category作为一个指针移动的特性和实行操作，我们有如下五类：

 Input Iterator　　Output Interator　　Forward Iterator　　Bidirectional Iterator　　Random Access Iterator

其中 input 和output这两种属于访问权限修饰，其他的三种依次深入，我们可以从下面代码中看出

struct  input_iterator{};    //只读 struct  output_iterator{};　　 //只写 struct  forward_iterator: public  input_iterator{};　　　　 //写入型，单项型操作 struct  bidirectional_iterator: public  forward_iterator{};   //可双向移动 struct  random_access_iterator: public  bidirectional_iterator{};    //可进行跳跃访问，涵盖所有指针的运算能力

　　c++中的多态性中有一个重载的概念，也就是说有如下例子

#include<iostream><br>using namespace std;<br>class base { //empty }; class  deriver: public  base { //empty }; void  test(base &) { //empty; }<br> int  main()<br>{<br>base b;<br>deriver d;<br>test(b);    //ok <br>test(d);    //ok<br>}

　这样，我们就可以写更少的函数来实现我们需要的所有方法

  好，为了使上述居多的描述更加清晰可见，思路更加清晰，上一大段代码进行分析

  

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#include<iostream> using  namespace  std; struct  input_iterator{}; struct  output_iterator{}; struct  forward_iterator: public  input_iterator{}; struct  bidirectional_iterator:forward_iterator{}; struct  random_access_iterator:bidirectional_iterator{}; template < typename  Category, typename  T, typename  Distance= ptrdiff_t , typename  Pointer=T*, typename  Reference=T&> struct  iterator {      typedef  Category iterator_category;      typedef  T        value_type;      typedef  Pointer  pointer;      typedef  Reference reference;      typedef  Distance difference_type; }; template < typename  Iterator> struct  Iterator_traitss {      typedef  typename  Iterator::iterator_catergory   iterator_category;      typedef  typename  Iterator::value_type       value_type;      typedef  typename  Iterator::pointer      pointer;      typedef  typename  Iterator::reference    　　　　　reference;      typedef  typename  Iterator::difference_type      difference_type; }; template < typename  T> struct  iterator_traitss<T*> {      typedef  random_access_iterator          　　　　　　　　　　　　　　iterator_category;      typedef  T                               value_type;      typedef  ptrdiff_t                        　　　　difference_type;      typedef  T*                              pointer;      typedef  T&                              reference; }; template < typename  T> struct  iterator_traitss< const  T*> {      typedef  random_access_iterator          　　　　　　　　　iterator_category;      typedef  T                           value_type;      typedef  ptrdiff_t                        difference_type;      typedef  const  T*                        pointer;      typedef  const  T&                        reference; }; template < typename  Iterator> inline  typename  iterator_traits<Iterator>::iterator_category      iterator_category( const  Iterator&) {      typedef  typename  iterator_traitss<Iterator>::iterator_category category;      return  category(); } int  main() { }

　　

   通过上述代码我们可以清晰看到，有一个iterator类模板，我们在其中的模板参数除了第一个参数外，其他的都有默认值，这个和我们现在使用的vector<T>等其中的Iterator是一致的 。

  有了iterator模板后，我们需要一个强有劲的过滤器，那就是iterator_traits，这个可以将模板参数不管是什么样的，统统封装成统一的typedef，例如 value_type的形成。

  这样我们就可以很方便的进行下面的操作。请注意在iterator_traits中T*的特化还有const T*的特化那里，iterator_category的原名是random_access_iterator.

  总结：

     我们可以通过typedef机制，隐藏，集中一类特性。

     我们可以通过模板参数推导机制，针对同一别名的不同类型进行不同操作。为了效率因素，进行编译期多态而非运行期多态。