类模板pointee

template <class Dereferenceable>
struct pointee
{
    typedef /* see below */ type;
};

type根据以下算法确定，其中x是一个对象，类型为可解引:

if ( ++x is ill-formed )
{
    return ``Dereferenceable::element_type``
}
else if (``*x`` is a mutable reference to
         std::iterator_traits<Dereferenceable>::value_type)
{
    return iterator_traits<Dereferenceable>::value_type
}
else
{
    return iterator_traits<Dereferenceable>::value_type const
}

类模板indirect_reference

template <class Dereferenceable>
struct indirect_reference
{
    typedef /* see below */ type;
};

type根据以下算法确定，其中x是一个对象，类型为可解引:

if ( ++x is ill-formed )
    return ``pointee<Dereferenceable>::type&``
else
    std::iterator_traits<Dereferenceable>::reference

类模板indirect_iterator

template <
    class Iterator
  , class Value = use_default
  , class CategoryOrTraversal = use_default
  , class Reference = use_default
  , class Difference = use_default
>
class indirect_iterator
{
 public:
    typedef /* see below */ value_type;
    typedef /* see below */ reference;
    typedef /* see below */ pointer;
    typedef /* see below */ difference_type;
    typedef /* see below */ iterator_category;

    indirect_iterator();
    indirect_iterator(Iterator x);

    template <
        class Iterator2, class Value2, class Category2
      , class Reference2, class Difference2
    >
    indirect_iterator(
        indirect_iterator<
             Iterator2, Value2, Category2, Reference2, Difference2
        > const& y
      , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
    );

    Iterator const& base() const;
    reference operator*() const;
    indirect_iterator& operator++();
    indirect_iterator& operator--();
private:
   Iterator m_iterator; // exposition
};

不是迭代器提供支持。indirect_iterator的成员类型按照以下伪代码定义，其中V是iterator_traits<Iterator>::value_type

if (Value is use_default) then
    typedef remove_const<pointee<V>::type>::type value_type;
else
    typedef remove_const<Value>::type value_type;

if (Reference is use_default) then
    if (Value is use_default) then
        typedef indirect_reference<V>::type reference;
    else
        typedef Value& reference;
else
    typedef Reference reference;

if (Value is use_default) then
    typedef pointee<V>::type* pointer;
else
    typedef Value* pointer;

if (Difference is use_default)
    typedef iterator_traits<Iterator>::difference_type difference_type;
else
    typedef Difference difference_type;

if (CategoryOrTraversal is use_default)
    typedef iterator-category (
        iterator_traversal<Iterator>::type,``reference``,``value_type``
    ) iterator_category;
else
    typedef iterator-category (
        CategoryOrTraversal,``reference``,``value_type``
    ) iterator_category;

indirect_iteratorrequirements

表达式*v，其中v是一个对象，其类型为iterator_traits<Iterator>::value_type应为有效表达式且可转换为reference. Iterator应模拟由iterator_category. 值, 参考和差值指示的遍历概念。应选择value_type, reference和difference_type使得iterator_category.

满足由iterator_traits<Iterator>::value_type指示的要求。[注意：如果值参数不是use_default，则value_type成员的默认值推导算法暗示了进一步的要求。]

indirect_iterator模型

除了由iterator_category和iterator_traversal<indirect_iterator>::type指示的概念外，indirect_iterator的特化模拟了以下概念，其中v是一个对象，其类型为iterator_traits<Iterator>::value_type:

• 可读迭代器，如果reference(*v)可转换为value_type.
• 可写迭代器，如果reference(*v) = t是有效表达式（其中t是一个对象，类型为indirect_iterator::value_type)
• 左值迭代器，如果reference是引用类型。

indirect_iterator<X,V1,C1,R1,D1>与indirect_iterator<Y,V2,C2,R2,D2>当且仅当X与Y.

indirect_iterator操作

除了上面描述的概念所需的操作外，indirect_iterator的特化还提供了以下操作。

indirect_iterator();

indirect_iterator(Iterator x);

template <
    class Iterator2, class Value2, unsigned Access, class Traversal
  , class Reference2, class Difference2
>
indirect_iterator(
    indirect_iterator<
         Iterator2, Value2, Access, Traversal, Reference2, Difference2
    > const& y
  , typename enable_if_convertible<Iterator2, Iterator>::type* = 0 // exposition
);

Iterator const& base() const;

reference operator*() const;

indirect_iterator& operator++();

indirect_iterator& operator--();

类模板reverse_iterator

template <class Iterator>
class reverse_iterator
{
public:
  typedef iterator_traits<Iterator>::value_type value_type;
  typedef iterator_traits<Iterator>::reference reference;
  typedef iterator_traits<Iterator>::pointer pointer;
  typedef iterator_traits<Iterator>::difference_type difference_type;
  typedef /* see below */ iterator_category;

  reverse_iterator() {}
  explicit reverse_iterator(Iterator x) ;

  template<class OtherIterator>
  reverse_iterator(
      reverse_iterator<OtherIterator> const& r
    , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
  );
  Iterator const& base() const;
  reference operator*() const;
  reverse_iterator& operator++();
  reverse_iterator& operator--();
private:
  Iterator m_iterator; // exposition
};

如果Iterator模拟随机访问遍历迭代器和可读左值迭代器，然后iterator_category可转换为random_access_iterator_tag。否则，如果Iterator模拟双向遍历迭代器和可读左值迭代器，则iterator_category可转换为bidirectional_iterator_tag。否则，iterator_category可转换为input_iterator_tag.

reverse_iteratorrequirements

Iterator必须是双向遍历迭代器的模型。类型iterator_traits<Iterator>::reference必须是*i，其中i是一个对象，类型为Iterator.

reverse_iterator模型

一个特化reverse_iterator模拟与其Iterator参数相同的迭代器遍历和迭代器访问概念。此外，它可能模拟下表中指定的旧迭代器概念

reverse_iterator<X>与reverse_iterator<Y>当且仅当X与Y.

reverse_iterator操作

除了参数所模拟的概念所要求的操作之外，reverse_iterator, reverse_iterator还提供了以下操作。

reverse_iterator();

explicit reverse_iterator(Iterator x);

template<class OtherIterator>
reverse_iterator(
    reverse_iterator<OtherIterator> const& r
  , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
);

Iterator const& base() const;

reference operator*() const;

Iterator tmp = m_iterator;
return *--tmp;

reverse_iterator& operator++();

reverse_iterator& operator--();

类模板transform_iterator

template <class UnaryFunction,
          class Iterator,
          class Reference = use_default,
          class Value = use_default>
class transform_iterator
{
public:
  typedef /* see below */ value_type;
  typedef /* see below */ reference;
  typedef /* see below */ pointer;
  typedef iterator_traits<Iterator>::difference_type difference_type;
  typedef /* see below */ iterator_category;

  transform_iterator();
  transform_iterator(Iterator const& x, UnaryFunction f);

  template<class F2, class I2, class R2, class V2>
  transform_iterator(
        transform_iterator<F2, I2, R2, V2> const& t
      , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition only
      , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
  );
  UnaryFunction functor() const;
  Iterator const& base() const;
  reference operator*() const;
  transform_iterator& operator++();
  transform_iterator& operator--();
private:
  Iterator m_iterator; // exposition only
  UnaryFunction m_f;   // exposition only
};

如果参考是use_default然后reference成员transform_iterator是result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type。否则，reference是参考.

如果值是use_default然后value_type成员是remove_cv<remove_reference<reference> >::type。否则，value_type是值.

如果Iterator模型 Readable Lvalue Iterator，并且如果Iterator模型 Random Access Traversal Iterator，则iterator_category可转换为random_access_iterator_tag。否则，如果Iterator模型 Bidirectional Traversal Iterator，则iterator_category可转换为bidirectional_iterator_tag否则iterator_category可转换为forward_iterator_tag。如果Iterator不模型 Readable Lvalue Iterator，则iterator_category可转换为input_iterator_tag.

transform_iteratorrequirements

类型UnaryFunction必须是 Assignable、Copy Constructible，并且表达式f(*i)必须是有效的，其中f是一个对象，类型为UnaryFunction, i是一个对象，类型为Iterator的 const 对象，其中f(*i)的类型必须是result_of<UnaryFunction(iterator_traits<Iterator>::reference)>::type.

参数Iterator都必须是 Readable Iterator。

transform_iterator模型

生成的transform_iterator模型以下概念中最精炼的、同时也被模型为Iterator.

• Writable Lvalue Iterator，如果transform_iterator::reference是一个非 const 引用。
• Readable Lvalue Iterator，如果transform_iterator::reference是一个 const 引用。
• 否则为可读迭代器（Readable Iterator）。

该transform_iterator模型最精炼的标准遍历概念，同时也被Iterator参数。

如果transform_iterator是 Readable Lvalue Iterator 的模型，那么它根据Iterator参数模型，模型以下原始迭代器概念。

如果transform_iterator是 Writable Lvalue Iterator 的模型，那么它是一个可写迭代器（如旧迭代器要求中所定义）。

transform_iterator<F1, X, R1, V1>与transform_iterator<F2, Y, R2, V2>当且仅当X与Y.

transform_iterator操作

除了参数所模拟的概念所要求的操作之外，transform_iterator, transform_iterator还提供了以下操作。

transform_iterator();

transform_iterator(Iterator const& x, UnaryFunction f);

template<class F2, class I2, class R2, class V2>
transform_iterator(
      transform_iterator<F2, I2, R2, V2> const& t
    , typename enable_if_convertible<I2, Iterator>::type* = 0      // exposition only
    , typename enable_if_convertible<F2, UnaryFunction>::type* = 0 // exposition only
);

UnaryFunction functor() const;

Iterator const& base() const;

reference operator*() const;

transform_iterator& operator++();

transform_iterator& operator--();

类模板filter_iterator

template <class Predicate, class Iterator>
class filter_iterator
{
 public:
    typedef iterator_traits<Iterator>::value_type value_type;
    typedef iterator_traits<Iterator>::reference reference;
    typedef iterator_traits<Iterator>::pointer pointer;
    typedef iterator_traits<Iterator>::difference_type difference_type;
    typedef /* see below */ iterator_category;

    filter_iterator();
    filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());
    filter_iterator(Iterator x, Iterator end = Iterator());
    template<class OtherIterator>
    filter_iterator(
        filter_iterator<Predicate, OtherIterator> const& t
        , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
        );
    Predicate predicate() const;
    Iterator end() const;
    Iterator const& base() const;
    reference operator*() const;
    filter_iterator& operator++();
private:
    Predicate m_pred; // exposition only
    Iterator m_iter;  // exposition only
    Iterator m_end;   // exposition only
};

如果Iterator模型 Readable Lvalue Iterator 和 Bidirectional Traversal Iterator，然后iterator_category可转换为std::bidirectional_iterator_tag。否则，如果Iterator模型 Readable Lvalue Iterator 和 Forward Traversal Iterator，然后iterator_category可转换为std::forward_iterator_tag否则iterator_category可转换为std::input_iterator_tag.

filter_iteratorrequirements

该Iterator参数必须满足 Readable Iterator 和 Single Pass Iterator 的要求，或者满足 Input Iterator 的要求。

该谓词参数必须是 Assignable、Copy Constructible，并且表达式p(x)必须是有效的，其中p是一个对象，类型为谓词, x是一个对象，类型为iterator_traits<Iterator>::value_type的 const 对象，其中p(x)必须可转换为bool.

filter_iterator模型

模型filter_iterator的模型取决于Iterator参数模型，具体如下表所示。

filter_iterator<P1, X>与filter_iterator<P2, Y>当且仅当X与Y.

filter_iterator操作

除了概念所要求的那些操作外，filter_iterator满足，filter_iterator还提供了以下操作。

filter_iterator();

filter_iterator(Predicate f, Iterator x, Iterator end = Iterator());

filter_iterator(Iterator x, Iterator end = Iterator());

template <class OtherIterator>
filter_iterator(
    filter_iterator<Predicate, OtherIterator> const& t
    , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0 // exposition
    );``

Predicate predicate() const;

Iterator end() const;

Iterator const& base() const;

reference operator*() const;

filter_iterator& operator++();

类模板counting_iterator

template <
    class Incrementable
  , class CategoryOrTraversal = use_default
  , class Difference = use_default
>
class counting_iterator
{
public:
    typedef Incrementable value_type;
    typedef const Incrementable& reference;
    typedef const Incrementable* pointer;
    typedef /* see below */ difference_type;
    typedef /* see below */ iterator_category;

    counting_iterator();
    counting_iterator(counting_iterator const& rhs);
    explicit counting_iterator(Incrementable x);
    Incrementable const& base() const;
    reference operator*() const;
    counting_iterator& operator++();
    counting_iterator& operator--();
private:
    Incrementable m_inc; // exposition
};

如果差值参数是use_default则difference_type是一个未指定的带符号整型类型。否则difference_type是差值.

iterator_category是根据以下算法确定的

if (CategoryOrTraversal is not use_default)
    return CategoryOrTraversal
else if (numeric_limits<Incrementable>::is_specialized)
    return iterator-category(
        random_access_traversal_tag, Incrementable, const Incrementable&)
else
    return iterator-category(
         iterator_traversal<Incrementable>::type,
         Incrementable, const Incrementable&)

[注意：鼓励实现者提供

operator-和difference_type的实现，并在std::numeric_limits<Incrementable>::is_specialized为 true 的情况下避免溢出。]

counting_iteratorrequirements

该Incrementable参数应该是 Copy Constructible 和 Assignable 的。

如果iterator_category可转换为forward_iterator_tag或forward_traversal_tag，则以下语句必须是 well-formed 的

Incrementable i, j;
++i;         // pre-increment
i == j;      // operator equal

如果iterator_category可转换为bidirectional_iterator_tag或bidirectional_traversal_tag，则以下表达式必须也是 well-formed 的

--i

如果iterator_category可转换为random_access_iterator_tag或random_access_traversal_tag，则以下语句必须也是有效的

counting_iterator::difference_type n;
i += n;
n = i - j;
i < j;

counting_iterator模型

的特化counting_iterator模型 Readable Lvalue Iterator。此外，它们还模型与其iterator_category可转换的迭代器标签相对应的概念。另外，如果CategoryOrTraversal不是use_default则counting_iterator模型与迭代器标签相对应的概念CategoryOrTraversal。否则，如果numeric_limits<Incrementable>::is_specialized，那么counting_iterator模型 Random Access Traversal Iterator。否则，counting_iterator模型与Incrementable.

counting_iterator<X,C1,D1>与counting_iterator<Y,C2,D2>当且仅当X与Y.

counting_iterator操作

除了参数所模拟的概念所要求的操作之外，counting_iterator, counting_iterator还提供了以下操作。

counting_iterator();

counting_iterator(counting_iterator const& rhs);

explicit counting_iterator(Incrementable x);

reference operator*() const;

counting_iterator& operator++();

counting_iterator& operator--();

Incrementable const& base() const;

类模板function_output_iterator

头文件

#include <boost/iterator/function_output_iterator.hpp>

template <class UnaryFunction>
class function_output_iterator {
public:
  typedef std::output_iterator_tag iterator_category;
  typedef void                     value_type;
  typedef void                     difference_type;
  typedef void                     pointer;
  typedef void                     reference;

  explicit function_output_iterator();

  explicit function_output_iterator(const UnaryFunction& f);

  /* see below */ operator*();
  function_output_iterator& operator++();
  function_output_iterator& operator++(int);
private:
  UnaryFunction m_f;     // exposition only
};

function_output_iteratorrequirements

UnaryFunction必须是 Assignable 和 Copy Constructible。

function_output_iterator模型

function_output_iterator是 Writable 和 Incrementable Iterator 概念的模型。

function_output_iterator操作

explicit function_output_iterator(const UnaryFunction& f = UnaryFunction());

operator*();

function_output_iterator& operator++();

function_output_iterator& operator++(int);