c++ - 为基类设计一个基迭代器

Question

我目前正在设计一个接口(interface)(下例中的 Base)，它提供了几个虚拟方法，包括 begin() 和 end()。这两个方法简单地返回相应的迭代器，就像在类的任何其他集合中一样。派生类应该实现这些方法并返回它们对迭代器的特定实现。

以下(简化的)示例显示了一个派生类，它使用 boost::transform_iterator 来转换私有(private)内部整数列表。这个实现只是一个例子，实际上迭代的“事物”可以是别的东西，迭代器也是如此。

该示例有效，但我遇到一个问题。 main() 中的对象类型并没有隐藏使用的迭代器是 TransformIterator 类型的事实。基类将用于某种插件架构，其中每个插件都是一个共享库。插件不应该知道使用了哪种类型的迭代器，而应该完全依赖于抽象接口(interface)。有办法做到这一点吗？

#include <boost/iterator/transform_iterator.hpp>

#include <iostream>
#include <string>
#include <vector>

template<class Iterator>
class Base
{
public:
    virtual Iterator begin() = 0;
    virtual Iterator end() = 0;
};

struct toString
{
    std::string operator()(int number) const
    {
        return std::to_string(number);
    }
};

typedef boost::transform_iterator<toString, std::vector<int>::iterator> TransformIterator;

class Derived : public Base<TransformIterator>
{
public:
    Derived() : ints{132, 3, 6451, 12, 5} {}

    TransformIterator begin()
    {
        return boost::make_transform_iterator(ints.begin(), toString());
    }

    TransformIterator end()
    {
        return boost::make_transform_iterator(ints.end(), toString());
    }

private:
    std::vector<int> ints;
};

int main()
{
    Base<TransformIterator>* obj = new Derived();
    for(const auto& value : *obj)
    {
        std::cout << value.size() << std::endl;
    }
    return 0;
}

更多背景知识:这个具体示例基于读取配置文件的接口(interface)。目前我只打算为 YAML 文件提供一个实现，但其他格式如 XML 或老式 INI 也是可能的。因此是一个通用接口(interface)。

Answer 1

我最近在工作中的一个项目中做了一些非常相似的事情。我这样做的方法是引入一个抽象迭代器接口(interface)和一个迭代器访问该接口(interface)的类。这是一个简化版本:

template <class ValueType>
struct AbstractIterator
{
  virtual ValueType& dereference() const = 0;
  virtual void increment() = 0;
  // and so on...
};


template <class ValueType>
struct ClientIterator : public std::iterator<whatever>
{
  std::unique_ptr<AbstractIterator<ValueType>> it;

  ClientIterator(std::unique_ptr<AbstractIterator<ValueType>> it) : it(std::move(it)) {}

  ValueType& operator* const () { return it->dereference(); }
  ClientIterator& operator++ () { it>increment(); return *this; }

  // and so on...
};

struct Base
{
  typedef ClientIterator<std::string> Iterator;
  virtual Iterator begin() = 0;
  virtual Iterator end() = 0;
}


struct Derived : Base
{
  struct ServerIterator : AbstractIterator<std::string>
  {
    boost::transform_iterator<toString, std::vector<int>::iterator> it;

    virtual std::string& dereference() const override { return *it; }
    virtual void increment() override { ++it; }
  }

  virtual Iterator begin() override { return Iterator({new ServerIterator(something)}); }
  virtual Iterator end() override { return Iterator({new ServerIterator(anotherThing)}); }
};