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

示例

此示例展示了如何使用indirect_iterator通过指针数组来访问字符数组。接下来indirect_iterator与转换算法配合使用，将字符（递增一）复制到另一个数组中。源迭代器使用的是常量间接迭代器，目标迭代器使用的是可变间接迭代器。示例的最后一部分打印了原始字符数组，但这次使用的是make_indirect_iterator辅助函数，以更简洁的方式表达。

char characters[] = "abcdefg";
const int N = sizeof(characters)/sizeof(char) - 1; // -1 since characters has a null char
char* pointers_to_chars[N];                        // at the end.
for (int i = 0; i < N; ++i)
  pointers_to_chars[i] = &characters[i];

// Example of using indirect_iterator

boost::indirect_iterator<char**, char>
  indirect_first(pointers_to_chars), indirect_last(pointers_to_chars + N);

std::copy(indirect_first, indirect_last, std::ostream_iterator<char>(std::cout, ","));
std::cout << std::endl;


// Example of making mutable and constant indirect iterators

char mutable_characters[N];
char* pointers_to_mutable_chars[N];
for (int j = 0; j < N; ++j)
  pointers_to_mutable_chars[j] = &mutable_characters[j];

boost::indirect_iterator<char* const*> mutable_indirect_first(pointers_to_mutable_chars),
  mutable_indirect_last(pointers_to_mutable_chars + N);
boost::indirect_iterator<char* const*, char const> const_indirect_first(pointers_to_chars),
  const_indirect_last(pointers_to_chars + N);

std::transform(const_indirect_first, const_indirect_last,
               mutable_indirect_first, std::bind1st(std::plus<char>(), 1));

std::copy(mutable_indirect_first, mutable_indirect_last,
          std::ostream_iterator<char>(std::cout, ","));
std::cout << std::endl;


// Example of using make_indirect_iterator()

std::copy(boost::make_indirect_iterator(pointers_to_chars),
          boost::make_indirect_iterator(pointers_to_chars + N),
          std::ostream_iterator<char>(std::cout, ","));
std::cout << std::endl;

找到。输出是

a,b,c,d,e,f,g,
b,c,d,e,f,g,h,
a,b,c,d,e,f,g,

该示例的源代码可以在这里找到。