C++中的多态迭代器

Question

我正在尝试在 C++ 中实现多态迭代器。基本上，我需要它才能应用过滤器，以便迭代器根据相关条件跳过一些项目。所以我创建了一个带有抽象接口的GoF-like 迭代器，这允许我从中派生一个过滤的迭代器并实现所需的逻辑。我也更喜欢基于接口的迭代器而不是模板迭代器，因为它们允许隐藏实现而不会导致混乱的鸭子类型模板。

但是，多态迭代器不能按值返回（与 STL 迭代器相反），所以我必须传递指针，这很容易变得像这种情况一样危险，这似乎合乎逻辑但会导致内存泄漏：

Iter* Collection::GetIter() {...} // new IterImpl
DoSomething(Iter*) {...} // doesn't do delete

DoSomething(Collection.GetIter()); // convenient, but wrong :\

显而易见的解决方案是使用某种智能指针来控制迭代器的生命周期，但人们常说接口应该尽可能简单和通用，所以应该避免智能指针？

如果您在 C++ 中使用过多态迭代器，这个问题是如何解决的？还是基于模板的迭代器是 C++ 中唯一“好”的迭代方式？谢谢。

Answer 1

通常的做法是使用编译时多态而不是运行时多态；这使编译器有更多机会使用迭代器优化代码，并且通常在现代 C++ 中更惯用。

如果您确实需要运行时多态行为，那么将多态性封装在迭代器本身中而不将其暴露在外部可能是最简单的。您可以使用诸如function 之类的多态函数包装器来完成此操作，该包装器可在 Boost、C++ TR1 和 C++0x 中找到。我在这里提供了一个基于我的一个爱好项目中的过滤器迭代器的示例：

template <typename ForwardIt>
class filter_iterator
    : public std::iterator<
          std::forward_iterator_tag, 
          typename std::iterator_traits<ForwardIt>::value_type>

{
public:

    typedef typename std::iterator_traits<ForwardIt>::value_type ValueType;
    typedef typename std::function<bool(ValueType)> FunctionType;

    filter_iterator() { }

    explicit filter_iterator(ForwardIt end)
        : it_(end), end_(end) 
    {
    }

    filter_iterator(ForwardIt it, ForwardIt end, FunctionType is_filtered) 
        : it_(it), end_(end), is_filtered_(is_filtered)
    { 
        skip_filtered_elements(); 
    }

    const ValueType& operator*()  const { return it_.operator*();  }
    const ValueType* operator->() const { return it_.operator->(); }

    filter_iterator& operator++()   
    { 
        ++it_; skip_filtered_elements(); return *this; 
    }

    filter_iterator operator++(int) 
    { 
        filter_iterator it(*this); ++*this; return it; 
    }


    friend bool operator==(const filter_iterator& lhs,
                           const filter_iterator& rhs)
    {
        return lhs.it_ == rhs.it_;
    }

    friend bool operator!=(const filter_iterator& lhs,
                           const filter_iterator& rhs)
    {
        return !(lhs == rhs);
    }

private:

    void skip_filtered_elements()
    {
        while (it_ != end_ && is_filtered_(*it_))
            std::advance(it_, 1);
    }

    ForwardIt it_;
    ForwardIt end_;

    std::function<bool(const ValueType&)> is_filtered_;
};

template <typename ForwardIt>
filter_iterator<ForwardIt> make_filter_iterator(ForwardIt end)
{
    return filter_iterator<ForwardIt>(end);
}

template <typename ForwardIt, typename Function>
filter_iterator<ForwardIt> make_filter_iterator(ForwardIt it, 
                                                ForwardIt end, 
                                                Function f)
{
    return filter_iterator<ForwardIt>(it, end, f);
}

使用很简单。此示例（使用 C++0x lambda 表达式作为函数类型）演示了从范围中过滤奇数：

int main()
{
    std::array<int, 4> x = { 1, 2, 3, 4 };

    std::copy(make_filter_iterator(x.begin(), x.end(), [](int i) { return i % 2; }),
              make_filter_iterator(x.end()),
              std::ostream_iterator<int>(std::cout, " "));
}

Answer 2

这里有两个问题：

• 语法：STL 假定迭代器提供需要与实际项目匹配的特征（例如value_type、reference）。
• 语义：迭代器应该是可复制的。

请记住（在 C++ 中）迭代器不是范围，因此 ++ 操作很快就会变得混乱，因为您需要跳过一些项目，但是（使用传统实现）您无法知道有多少项目随时为您服务...

因此，如果您想要遵循 GOF 接口的多态迭代器，您将不得不放弃使用 STL 算法。

也就是说，实现多态迭代器是完全可行的：

struct IterBase
{
  virtual void increment() = 0;
  virtual void decrement() = 0;

  // others
};

class Iter
{
public:
  Iter& operator++() { base->increment(); return *this; }
  Iter operator++(int) { Iter tmp(*this); base->increment(); return tmp; }

  // others

private:
  std::unique_ptr<IterBase> base;
};

然后你需要编写所有的复制构造函数、赋值运算符和析构函数来做正确的事情......

不过，如果没有模板多态性，那么只有当您的迭代器仅用于同一类型时才值得...

Answer 3

可以使用包含某种形式的指针的迭代器来完成，然后将功能传递给指针。

虽然这样做你需要非常小心，而且我已经多次看到它做错了（包括我自己曾经爱过它，然后想知道为什么测试失败了......）

• 不要使用 shared_ptr！

幸运的是，我没有看到上面有人犯了使用 shared_ptr 的错误，但它有错误的语义，因为当你复制一个迭代器时，你有 2 个单独的副本。但是，如果它们包含一个 shared_ptr 并且您推进其中一个迭代器，另一个将随之移动 - 意外行为...

因此，每次复制时都需要进行克隆，但幸运的是，使用 C++0x，您可以在大部分时间移动而不是克隆。

您还需要知道，每次迭代的操作都会命中 v-table，这可能会导致它的运行速度比将“宏”方法设为多态（并且可能使用模板实现，因此您不需要重写代码）。

Answer 4

我在 Oli Charlesworth 的问题上看到了一个很好的解决方案，但并没有得到太多的赞誉（至少，没有我想的那么多）。

class Iterator
{
public:
    SmartPointer<IteratorImplementation> ItrPtr;

    //Delegate methods to ItrPtr
}

然后您可以通过值传递迭代器并将方法延迟到包含的智能指针；它基本上是一个实现“策略”模式的迭代器，策略表现出多态行为。

Answer 5

人们确实说界面应该尽可能简单和通用。在您的情况下，您将原始指针描述为“不可能”的东西。因此，我建议您使用智能指针的明显解决方案是可能的最简单和通用的技术。

为了使这个智能指针尽可能简单和通用，我会使用 stl 提供的智能指针之一，因为它们是最普遍的。

Answer 6

去过那里。做到了。

您可以做的是将您的迭代器接口隐藏在另一个迭代器后面。 假设您有几种迭代器，它们都隐藏在 IIterator 接口后面。

然后编写另一个类似迭代器的类，例如MyIterator，它包含一个指向 IIterator 的指针，它只是将所有调用转发给 IIterator，如下所示：

template <typename T>
class MyIterator
    {
    public:
       MyIterator() : m_iterator(nullptr) {}
       MyIterator(IIterator *it) : m_iterator(it) {}
       MyIterator &operator++()
          {
          if (m_iterator) m_iterator->operator++();
          return *this;
          }
       T &operator*() const
          {
          if (m_iterator) return m_iterator->operator*();
          else            throw an exception?
          }
    private
       IIterator *m_iterator;
    };

这个例子远未完成，但你应该明白了。