我可以将反向迭代器转换为正向迭代器吗？

Question

我有一个名为 Action 的类，它本质上是一个包装 Move 对象的双端队列。

因为我需要向前和向后遍历Moves 的双端队列，所以我有一个前向迭代器和一个reverse_iterator 作为类的成员变量。这样做的原因是因为我需要知道我什么时候已经超过了双端队列的“结束”，无论是前进还是后退。

类如下所示：

class Action
{
public:
    SetMoves(std::deque<Move> & dmoves) { _moves = dmoves; }
    void Advance();
    bool Finished() 
    {
        if( bForward )
            return (currentfwd==_moves.end());
        else
            return (currentbck==_moves.rend());
    }
private:
    std::deque<Move> _moves;
    std::deque<Move>::const_iterator currentfwd;
    std::deque<Move>::const_reverse_iterator currentbck;
    bool bForward;
};

Advance函数如下：

void Action::Advance
{
    if( bForward)
        currentfwd++;
    else
        currentbck++;
}

我的问题是，我希望能够检索到当前Move 对象的迭代器，而无需查询我是前进还是后退。这意味着一个函数返回一种类型的迭代器，但我有两种类型。

我应该忘记返回一个迭代器，而是返回一个对 Move 对象的 const 引用吗？

Answer 1

反向迭代器有一个成员base()，它返回一个对应的正向迭代器。请注意，这 不是 引用同一对象的迭代器 - 它实际上是指序列中的下一个对象。这样rbegin()对应end()，rend()对应begin()。

所以如果你想返回一个迭代器，那么你会做类似的事情

std::deque<Move>::const_iterator Current() const
{
    if (forward)
        return currentfwd;
    else
        return (currentbck+1).base();
}

不过，我更愿意返回一个引用，并将所有迭代细节封装在类中。

Answer 2

这正是促使STL设计开始的那种问题。有真正的原因：

1. 不将迭代器与容器一起存储
2. 使用接受任意迭代器的算法
3. 让算法评估整个范围，而不是一次评估单个项目

我怀疑您现在看到的或多或少只是真正问题的冰山一角。我的建议是退后一步，而不是问如何处理目前的设计细节，而是问一个更笼统的问题，关于你想要完成什么，以及如何最好地完成它最终结果。

对于那些主要关心标题中问题的人来说，答案是非常合格的“是”。特别是，reverse_iterator 有一个 base() 成员来执行此操作。资格虽然有些问题。

演示问题，考虑如下代码：

#include <iostream>
#include <vector>
#include <iterator>

int main() { 
    int i[] = { 1, 2, 3, 4};
    std::vector<int> numbers(i, i+4);

    std::cout << *numbers.rbegin() << "\n";
    std::cout << *numbers.rbegin().base() << "\n";
    std::cout << *(numbers.rbegin()+1).base() << "\n";

    std::cout << *numbers.rend() << "\n";
    std::cout << *numbers.rend().base() << "\n";
    std::cout << *(numbers.rend()+1).base() << "\n";
}

在这个特定的时刻在我的特定机器上运行它会产生以下输出：

4
0
4
-1879048016
1
-1879048016

总结：对于rbegin()，我们必须在转换为前向迭代器之前添加一个以获得有效的迭代器——但对于rend()，我们必须不添加在转换之前获得一个有效的迭代器。

只要您使用X.rbegin() 和X.rend() 作为通用算法的参数，就可以了——但经验表明，转换为前向迭代器通常会导致问题。

然而，最后，对于问题的主体（而不是标题），答案与上面给出的差不多：问题源于试图创建一个将集合与几个迭代器组合在一起的对象进入那个集合。解决这个问题，使用正向和反向迭代器的整个业务就变得没有意义了。

Answer 3

由于@987654321@ 是random access container（与std::vector 相同），因此最好在双端队列中使用单个整数索引进行两次遍历。

Answer 4

在我看来，您实际上在同一个班级中有两种不同的行为。

值得注意的是，您似乎只能以一种顺序遍历您的集合，否则如果您开始遍历然后更改 bforward 参数，您最终会遇到非常奇怪的情况。

就个人而言，我完全赞成公开这两个迭代器（即转发begin, end, rbegin and rend）。

你也可以返回一个简单的 Iterator 对象：

template <class T>
class Iterator
{
public:
  typedef typename T::reference_type reference_type;

  Iterator(T it, T end) : m_it(it), m_end(end) {}

  operator bool() const { return m_it != m_end; }

  reference_type operator*() const { return *m_it; }

  Iterator& operator++() { ++m_it; return *this; }

private:
  T m_it;
  T m_end;
};

template <class T>
Iterator<T> make_iterator(T it, T end) { return Iterator<T>(it,end); }

然后，您可以只返回这个简单的对象：

class Action
{
public:
  Action(std::deque<Move> const& d): m_deque(d) {} // const& please

  typedef Iterator< std::deque<Move>::iterator > forward_iterator_type;
  typedef Iterator< std::deque<Move>::reverse_iterator > backward_iterator_type;

  forward_iterator_type forward_iterator()
  {
    return make_iterator(m_deque.begin(), m_deque.end());
  }

  backward_iterator_type backward_iterator()
  {
    return make_iterator(m_deque.rbegin(), m_deque.rend());
  }


private:
  std::deque<Move> m_deque;
};

或者如果你想在前向和后向遍历之间动态选择，你可以让 Iterator 成为一个纯虚拟接口，并且同时具有前向和后向遍历。

但实际上，如果您似乎只使用一个迭代器，我并没有真正看到存储前向和后向迭代器的意义：/

Answer 5

也许你应该重新考虑你对容器的选择。

通常你不需要使用反向迭代器来回退，

currentfwd--

会倒退，尽管它可能无法与 dequeue 一起工作（我假设你尝试过）。

您真正应该做的是在这里将您的类建模为 dequeue 的装饰器并实现您自己的 Action 迭代器。无论如何我都会这样做。