Class template pointee

template <class Dereferenceable>
struct pointee
{
    typedef /* see below */ 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
}

Class template indirect_reference

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

типопределяется по следующему алгоритму, гдеxявляется объектом типаСсылка:

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

Class template 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
};

Типы членовdirect_iteratorопределяются в соответствии со следующим псевдокодом, гдеVявляетсяiterator_traits::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_iterator requirements

Выражение*v, гдеvявляется объектомiterator_traits::value_type, должно быть действительным выражением и конвертируемым вэталон.Итератордолжен моделировать концепцию обхода, указаннуюитератор_категория.Значение,Ссылка, иСсылка, иРазницавыбирается таким образом, чтобызначение_тип,ссылкаиразличие_типсоответствовали требованиям, указаннымитератор_категория.

[Примечание: существуют дополнительные требования кiterator_traits::value_type, если параметрне являетсяuse_default, как подразумевается алгоритмом для выведения по умолчанию дляvalue_typeчлена.]

indirect_iterator models

В дополнение к понятиям, указаннымiterator_categoryиiterator_traversal::type, специализацияdirect_iteratorмоделирует следующие понятия, гдеvявляется объектомiterator_traits::value_type:

• Читаемый итератор, еслиссылка (*v)конвертируется взначение_тип.
• Записываемый итератор, еслиссылка (*v)=tявляется действительным выражением (гдеtявляется объектом типаindirect_iterator::value_type)
• Lvalue Iterator, еслиссылкаявляется эталонным типом.

direct_iteratorсовместим сdirect_iteratorтогда и только тогда, когдаXсовместим сY.

indirect_iterator operations

В дополнение к операциям, требуемым концепциями, описанными выше, специализацииdirect_iteratorобеспечивают следующие операции.

direct_iterator();

direct_iterator(Iteratorx);

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
);

Итераторconst&base()const;

эталоноператор*()const;

direct_iterator&operator++();

direct_iterator&operator--();

Class template 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
};

ЕслиИтератормодели Random Access Traversal Iterator и Readable Lvalue Iterator, тоитератор_категорияконвертируется вслучайный_access_iterator_tag. В противном случае, еслиИтератормодели Двунаправленный Траверсальный Итератор и Считываемый Итератор Значения, тоитератор_категорияявляется конвертируемым вдвунаправленный_iterator_tag. В противном случаеитератор_категорияпреобразуется ввходной_iterator_tag.

reverse_iterator requirements

Итератордолжен быть моделью Двунаправленного Траверсального Итератора. Типiterator_traits:: ссылкадолжна быть типа*i, гдеiявляется объектом типаИтератор.

reverse_iterator models

Специализацияreverse_iteratorмоделирует те же концепции обхода итератора и доступа итератора, смоделированные его.Итератораргумент. Кроме того, он может моделировать старые концепции итератора, указанные в следующей таблице:

reverse_iteratorсовместим сreverse_iterator, если и только еслиXсовместим сY.

reverse_iterator operations

В дополнение к операциям, требуемым концепциями, смоделированнымиreverse_iterator,reverse_iterator, предусмотрены следующие операции.

reverse_iterator();

явныйобратный_iterator(Iteratorx);

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

Итераторconst&base()const;

эталоноператор*()const;

Iterator tmp = m_iterator;
return *--tmp;

reverse_iterator&operator++();

reverse_iterator&operator--();

Class template 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, тоэталончленtransform_iteratorявляетсярезультатом_of::reference>::type]. В противном случаессылкаявляетсяссылка.

Еслизначениеявляетсяuse_default, тозначение_typeчленудалите_cv>::type. В противном случаезначение_типявляетсязначением.

ЕслиИтератормодели Считываемый Итератор Значения и еслиИтератормодели Случайный Доступ Поперечный Итератор, тоитератор_категорияконвертируем вслучайный_access_iterator_tag. В противном случае, еслиИтератормодели Двунаправленный Траверсальный Итератор, тоитератор_категориябинаправленный_iterator_tag.В противном случаеитератор_категорияявляется конвертируемым впередний_iterator_tag.ЕслиИтераторне моделирует Считываемый Lvalue Итератор, тоитератор_категорияявляется конвертируемым ввход_iterator_tag.

transform_iterator requirements

ТипUnaryFunctionдолжен быть уступчивым, копируемым, конструируемым, а выражениеf(*i)должно быть действительным, еслиfявляется объектом типа,iявляется объектом типаИтератор, и где типf(*i)должен бытьрезультатом_of::reference)>::type.

АргументИтератордолжен моделировать читаемый итератор.

transform_iterator models

Полученный в результатеTransform_iteratorмоделирует наиболее совершенную из следующих моделей, которая также смоделированаIterator.

• Записываемый Lvalue Iterator, еслиTransform_iterator::referenceявляется неконст-ссылкой.
• Считываемый Lvalue Iterator, еслиTransform_iterator::referenceявляется const reference.
• Читаемый итератор иначе.

МодельTransform_iteratorявляется наиболее усовершенствованной стандартной концепцией обхода, которая смоделирована.Итератораргумент.

ЕслиTransform_iteratorявляется моделью Readable Lvalue Iterator, то он моделирует следующие оригинальные концепции итератора в зависимости от того, чтоИтератормодели аргументов.

Еслипреобразовать_iteratorмодели Writable Lvalue Iterator, то это изменяемый итератор (как определено в старых требованиях к итератору).

Transform_iteratorX,R1,V1>совместим сTransform_iteratorY,R2,V2>, если и только еслиXсовместим сY.

transform_iterator operations

В дополнение к операциям, требуемым концепциями, смоделированнымиTransform_iterator,Transform_iteratorобеспечивает следующие операции.

Transform_iterator();

transform_iterator(Iteratorconst&x,UnaryFunctionf);

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
);

UnaryFunctionfunctor()const;

Итераторconst&base()const;

эталоноператор*()const;

transform_iterator&operator++();

transform_iterator&operator--();

Class template 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
};

ЕслиИтератормодели Считываемый Итератор Значения и Двунаправленный Траверсальный Итератор, тоитератор_категорияконвертируется вstd::bidirectional_iterator_tag. В противном случае, еслиИтератормодели Считываемый итератор Lvalue и Итератор переднего хода, тоитератор_категорияявляется конвертируемым вstd::forward_iterator_tag. В противном случаеитератор_категорияявляется конвертируемым вstd::input_iterator_tag.

filter_iterator requirements

АргументИтератордолжен соответствовать требованиям Итератора для чтения и Итератора для одиночного прохода или он должен соответствовать требованиям Итератора ввода.

АргументПредикатадолжен быть приемлемым, копируемым конструируемым, а выражениеp(x)должно быть действительным, еслиpявляется объектом типаПредиката,xявляется объектом типаитератора_traits::value_type, и если типp(x)должен быть конвертируемым вbool.

filter_iterator models

Представления о том, чтомодели фильтра-итераторазависят от того, какие понятияИтератормодели аргументов, как указано в следующих таблицах.

filter_iteratorX>совместим сfilter_iteratorY>, если и только еслиXсовместим сY.

filter_iterator operations

В дополнение к этим операциям, требуемым концепциями, которыемодели filter_iterator,фильтр_iteratorобеспечивают следующие операции.

filter_iterator();

filter_iterator (Предсказательf,Итераторx,Итераторконец=Итератор());

filter_iterator (Итераторx,Итераторконец=Итератор());

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

ПредикатПредикат()const;

Итераторконецконст;

Итераторconst&base()const;

эталоноператор*()const;

filter_iterator&operator++();

Class template 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, тоРазница_typeявляется неопределенным подписанным интегральным типом. Иначеdifference_type—Difference.

итератор_категорияопределяется по следующему алгоритму:

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&)

[Note: implementers are encouraged to provide an implementation of

operator- and a difference_type that avoids overflows in the cases where std::numeric_limits<Incrementable>::is_specialized is true.]

counting_iterator requirements

Дополняемыйаргумент должен быть конструктивен и приемлем.

Еслиiterator_categoryконвертируется вforward_iterator_tagилиforward_traversal_tag, то должно быть хорошо сформировано следующее:

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

Еслиiterator_categoryконвертируется вbidirectional_iterator_tagилиbidirectional_traversal_tag, то должно быть также хорошо сформировано следующее выражение:

--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 models

СпециализацииCounting_iteratorмодель Readable Lvalue Iterator. Кроме того, они моделируют понятия, соответствующие тегам итератора, к которым ихитератор_категорияявляется конвертируемым. Кроме того, еслиCategoryOrTraversalне являетсяuse_default, тоcounting_iteratorмоделирует концепцию, соответствующую тегу итератораКатегорияПутешествия. В противном случае, еслиnumeric_limits::is_specialized, тоcounting_iteratorмодели Random Access Traversal Iterator. В противном случаеCounting_iteratorмоделирует те же концепции обхода итератора, что и.Невероятный.

Counting_iteratorсовместим сCounting_iterator, если и только еслиXсовместим сY.

counting_iterator operations

В дополнение к операциям, требуемым концепциями, смоделированнымиCounting_iterator,Counting_iteratorобеспечивает следующие операции.

Counting_iterator();

counting_iteratorconst&rhs;

эксплицитныйсчетчик_iterator(Incrementablex);

эталоноператор*()const;

counting_iterator&operator++();

counting_iterator&operator--();

const&base()const;

Class template function_output_iterator

Header

#include <boost/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_iterator requirements

UnaryFunctionдолжна быть уступчивой и копируемой.

function_output_iterator models

function_output_iteratorявляется моделью концепций Writable and Incrementable Iterator.

function_output_iterator operations

явнаяфункция_output_iterator(constUnaryFunction&f=UnaryFunction());

оператор*();

function_output_iterator&operator++();

function_output_iterator&operator++(int);