看的越多，好像关于迭代器也就越难写了，呵呵不过，还是做个记录，聊以自慰吧

1、首先迭代器是一种广义的指针，一个数组也同样可以作为一种迭代器的具象，迭代器提供对一个容器中的对象的访问方法，并且定义了容器中对象的范围。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器不仅仅是指针，因此你不能认为他们一定具有地址值。例如，一个数组索引，也可以认为是一种迭代器。

2、迭代器在STL中共有几种类型：

·        Input iterators 提供对数据的只读访问。
·        Output iterators 提供对数据的只写访问
·        Forward iterators 提供读写操作，并能向前推进迭代器。只能进行++操作
·        Bidirectional iterators提供读写操作，并能向前和向后操作。基类是Bidirectional iterators可以进行++  --操作
·        Random access iterators提供读写操作，并能在数据中随机移动。基类是Bidirectional iterators,可以进行+=  -=操作

这是五种迭代器类型，但是我们知道vector  dequeue   list map等等，的泛型迭代器，会有不同的实现，也即上述迭代器种类只是概念性质的分类，比如vector的iterator的实现其就在vector.h文件当中而不是iterator.h文件当中，该文件的作用，笔者尚未弄清，限于能力请见谅！！！

在vector的iterator类型即为Random access iterators类型，随机访问的迭代器

在iterator模板类中，定义了5个成员类别：value_type,difference_type pointer，reference, iterator_category，用作所有其它迭代器的基类。


    back_insert_iterator模板类，是一种输出迭代器，用于在容器对象的尾部追加新的元素。该迭代器被赋值时，调用了容器对象的push_back()成员函数。该迭代器的自增操作实际上为空操作。
    back_inserter模板函数，用于方便地由一个容器构造出back_insert_iterator
 


  front_insert_iterator模板类，是一种输出迭代器，用于在容器对象的头部插入新的元素。该迭代器被赋值时，调用了容器对象的push_front()成员函数。该迭代器的自增操作实际上为空操作。
    front_inserter模板函数，用于方便地由一个容器构造出front_insert_iterator
    insert_iterator模板类，是一种输出迭代器，用于在容器对象的指定位置插入新的元素。该迭代器被赋值时，调用了容器对象的insert()成员函数。该迭代器的自增操作实际上为空操作。
    insert_inserter模板函数，用于方便地由一个容器构造出insert_iterator

 

在STL定义的容器中，string，vector与deque提供了随机访问迭代器，list、set、multiset、map、multimap提供了双向迭代器。

迭代器根据的是23种设计模式中的迭代器模式，该模式的主要特点就是隐藏内部细节，继而可以遍历整个中心数据，而Iterator就是根据传入数据进行遍历的！！！！迭代器主要有两个，一者迭代器，也即遍历所有内容的广义迭代器，二者容器，容器是广义的数组，我们需要得到这个容器的内容的指针，然后会在迭代器中记录当前指针记录读取容器中的位置，需要记录两个，一个是容器的实力对象，二者记录容器元素的指针，进行移动

进行遍历。其C++代码实现迭代器如下：

#include <iostream>
using namespace std;
template<class T>
class Iterator_m
{
public:
  virtual T* First() = 0;
  virtual T* Next() = 0;
  virtual bool isDone() = 0;
};

template<class T>
class TList
{
private:
  T* m_list;
  int max_num;
  int m_cur_num;
public:
  T* getFirst()
  {
    return m_list;
  }
  int getNum()
  {
    return m_cur_num;
  }
  void Append(T m)
  {
    if (m_cur_num == max_num)
    {
      //当前空间已经使用完了，开辟新的空间，首先进行
      T* new_list = new T[max_num * 2];
      for (int i = 0; i < max_num; i++)
      {
        new_list[i] = m_list[i];
        delete m_list;
        m_list = new_list;
      }
      max_num *= 2;
    }
    m_list[m_cur_num] = m;
    m_cur_num++;
  }
  TList()
  {
    m_cur_num = 0;
    max_num = 24;
    m_list = new T[max_num];
  }
  Iterator_m<T>* createIterator()
  {
    return  new ConcerteIterator<T>(this);
  }
};
template<class T>
class ConcerteIterator :public Iterator_m<T>
{
private:
  TList<T>* m_hinstance;
  T* m_element;
  int m_cur_pos;
public:
  ConcerteIterator(TList<T>*m)
  {
    m_hinstance = m;
    m_cur_pos = 0;
    m_element = m->getFirst();
  }
  T* Next()
  {
    return  &(m_element[m_cur_pos++]);
  }
  T* First()
  {
    m_element = m_hinstance->getFirst();
    m_cur_pos = 0;
    return m_element;
  }
  bool isDone()
  {
    //首先获得m_hinstance的总的数目和m_cur_pos比较
    if (m_cur_pos +1== m_hinstance->getNum())
    {
      return true;
    }
    return false;
  }
};

int main()
{
  TList<int> dsa;
  for (int i = 0; i < 20; i++)
  {
    dsa.Append(i);
  }
  //开始使用迭代器进行遍历
  Iterator_m<int>* mm = dsa.createIterator();
  //mm->First();
  while (!(mm->isDone()))
  {
    cout << *(mm->Next()) << endl;
  }
  return 0;
}


综上，其实迭代器就是一种封装的指针，其主要作用就是记录两个值，其一是容器实例的指针，其二记录当前迭代的位置，需要自定义实现isDone判断是否已经迭代到容器的末尾！！！！