iterator adapter

插入迭代器：将一般迭代器的赋值操作转变为插入操作。

insert iterator

当用户对inserter iterator作赋值操作时，就在inserter iterator类中定义的operator()中调用底层容器的插入操作（push_back,push_front,insert,etc.）.

以back_inserter插入迭代适配器为例：(front_inserter和inserter与该类相类似)

template <class _Container>

inline back_insert_iterator<_Container> back_inserter(_Container& __x) {

  return back_insert_iterator<_Container>(__x);

}

当用户调用back_inserter函数时，函数实际返回后向插入迭代器类（back_insert_iterator）对象，并将容器参数传递给后向插入迭代器类的构造函数。

后向插入迭代器类代码（back_insert_iterator）：

template <class _Container>

class back_insert_iterator {

protected:

  _Container* container;

public:

  typedef _Container          container_type;

  typedef output_iterator_tag iterator_category;

  typedef void                value_type;

  typedef void                difference_type;

  typedef void                pointer;

  typedef void                reference;

  explicit back_insert_iterator(_Container& __x) : container(&__x) {}

  back_insert_iterator<_Container>&

  operator=(const typename _Container::value_type& __value) {

    container->push_back(__value);

    return *this;

  }

  back_insert_iterator<_Container>& operator*() { return *this; }

  back_insert_iterator<_Container>& operator++() { return *this; }

  back_insert_iterator<_Container>& operator++(int) { return *this; }

};

类中有容器类指针_Container* container，指向待插入的容器。在类中定义的赋值操作符=中，调用了底层容器的push_back函数，将operator=参数__value插入到容器尾部。

类中还重载了迭代器操作符：dereference [],prefix_increment[++],post_increment[++(int)]。在其函数体中只是简单地返回当前迭代器本身（this），并未进行相应的前进等操作，说明对此类back_insert_iterator对象进行上述操作是不会产生什么效果。

结合例子分析：

#include<iostream>

#include<vector>

#include<algorithm>

#include<iterator>

using namespace std;

int main(){

	int ia[]={1,5,3,6,4,8,9};

	vector<int> ivec(ia,ia+7);

	ostream_iterator<int> outite(cout," ");

	copy(ia,ia+3,back_inserter(ivec));        //a

	copy(ivec.begin(),ivec.end(),outite);

        //1 5 3 6 4 8 9 1 5 3

	cout<<endl;

	return 0;

}

 程序中a行调用back_inserter函数，生成对ivec向量的后向迭代器对象（back_insert_iterator object），并将该对象传入到copy算法。在copy算法中将利用该对象作为函数，对容器中的对象进行处理。

 在程序中，后向迭代器对象只是被当作一个函数（functor）使用，对容器调用该对象提供的功能，而不是像传统的迭代器来访问数组中的元素，因此，对其进行dereference [*],prefix_increment[++],post_increment[++(int)]操作都不会产生什么效果。

程序的运行结果为：

1 5 3 6 4 8 9 1 5 3

reverse iterator

反向迭代器：将迭代器的移动方向倒转：前进变为后退，后退变为前进。

在某些容器类中定义反向迭代器成员，如vector:

template <class _Tp, class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) >

class vector : protected _Vector_base<_Tp, _Alloc>

{

    //...

    typedef value_type* iterator;   // vector的迭代器是普通指针

    typedef const value_type* const_iterator;

    typedef reverse_iterator<const_iterator> const_reverse_iterator;

    typedef reverse_iterator<iterator> reverse_iterator;

    reverse_iterator rbegin()

    { return reverse_iterator(end()); }

    const_reverse_iterator rbegin() const

    { return const_reverse_iterator(end()); }

    reverse_iterator rend()

    { return reverse_iterator(begin()); }

    const_reverse_iterator rend() const

    { return const_reverse_iterator(begin()); }

    //...

}

在上面的代码中，该类还定义了rbegin(),rend()等函数，可以返回容器的反向迭代器。

reverse_iterator类的定义如下：

template <class _RandomAccessIterator, class _Tp, class _Reference = _Tp&,

          class _Distance = ptrdiff_t>

class reverse_iterator {

  typedef reverse_iterator<_RandomAccessIterator, _Tp, _Reference, _Distance>

        _Self;

protected:

  _RandomAccessIterator current;

public:

  typedef random_access_iterator_tag iterator_category;

  typedef _Tp                        value_type;

  typedef _Distance                  difference_type;

  typedef _Tp*                       pointer;

  typedef _Reference                 reference;

  reverse_iterator() {}

  explicit reverse_iterator(_RandomAccessIterator __x) : current(__x) {}

  _RandomAccessIterator base() const { return current; }

  _Reference operator*() const { return *(current - 1); }

#ifndef __SGI_STL_NO_ARROW_OPERATOR

  pointer operator->() const { return &(operator*()); }

#endif /* __SGI_STL_NO_ARROW_OPERATOR */

  _Self& operator++() {

    --current;

    return *this;

  }

  _Self operator++(int) {

    _Self __tmp = *this;

    --current;

    return __tmp;

  }

  _Self& operator--() {

    ++current;

    return *this;

  }

  _Self operator--(int) {

    _Self __tmp = *this;

    ++current;

    return __tmp;

  }

  _Self operator+(_Distance __n) const {

    return _Self(current - __n);

  }

  _Self& operator+=(_Distance __n) {

    current -= __n;

    return *this;

  }

  _Self operator-(_Distance __n) const {

    return _Self(current + __n);

  }

  _Self& operator-=(_Distance __n) {

    current += __n;

    return *this;

  }

  _Reference operator[](_Distance __n) const { return *(*this + __n); }

};

迭代器的前进，后退等操作都与普通迭代器的方向相反。

  _Reference operator*() const { return *(current - 1); }

在解引用函数*定义中，函数先向前进一步，然后再对其解引用并返回，而正向迭代器则是直接解析其指向的元素。

stream iterator

流迭代器：将迭代器绑定到一个数据流（stream）对象上。包括istream_iterator和ostream_iterator。

ostream_iterator

istream iterator在类的内部有一个istream类型的指针。当用户对迭代器进行操作时，迭代器内部通过该指针指向的输入流对象，完成相应的操作。

template <class _Tp, class _Dist>

class istream_iterator {

  template <class _T1, class _D1>

  friend bool operator==(const istream_iterator<_T1, _D1>&,

                         const istream_iterator<_T1, _D1>&);

protected:

  istream* _M_stream;

  _Tp _M_value;

  bool _M_end_marker;

  void _M_read() {

    _M_end_marker = (*_M_stream) ? true : false;

    if (_M_end_marker) *_M_stream >> _M_value;

    _M_end_marker = (*_M_stream) ? true : false;

  }

public:

  typedef input_iterator_tag  iterator_category;

  typedef _Tp                 value_type;

  typedef _Dist               difference_type;

  typedef const _Tp*          pointer;

  typedef const _Tp&          reference;

  istream_iterator() : _M_stream(&cin), _M_end_marker(false) {}

  istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }

  reference operator*() const { return _M_value; }

  pointer operator->() const { return &(operator*()); }

  istream_iterator<_Tp, _Dist>& operator++() {

    _M_read();

    return *this;

  }

  istream_iterator<_Tp, _Dist> operator++(int)  {

    istream_iterator<_Tp, _Dist> __tmp = *this;

    _M_read();

    return __tmp;

  }

};

类中istream类指针_M_stream实现迭代器的数据输入操作。_M_value变量保存最近输入的值。该类的默认构造函数用cin初始化_M_stream成员，并设置流输入结束符。用户也可以自己指定其他输入流（如文件流等）来初始化输入流指针成员_M_stream。

istream_iterator对象通常配合算法使用，可以用输入流完成对容器的初始化或赋值等功能。在算法中会调用istream_iterator对象的前进操作符号，而在自增操作符函数体中，调用了_M_read函数，在_M_read函数中，先判断是否到达流结尾，若未到达结尾，则调用输入流的operator>> ,将输入值赋给_M_value，并更新到达结尾状态。解引用操作符则可返回当前的最新输入值_M_value。每次对istream_iterator对象调用operator++，都会引发数据输入，并将输入值保存在缓存变量中。

ostream_iterator

ostream_iterator 类完成数据的输出操作。于istream_iterator的差别主要在赋值操作符operator=中：

  ostream_iterator<_Tp>& operator=(const _Tp& __value) {

    *_M_stream << __value;

    if (_M_string) *_M_stream << _M_string;

    return *this;

  }

每次对ostream_iterator类对象调用赋值操作时，都会将右操作数 __value输出到指定的输出流中，并输入指定的分割字符串。

ostream_iterator类中*了其他几个操作符的功能，使得对其进行操作失效：

  ostream_iterator<_Tp>& operator*() { return *this; }

  ostream_iterator<_Tp>& operator++() { return *this; }

  ostream_iterator<_Tp>& operator++(int) { return *this; }