C++、多态和迭代器

Question

我想要一个存储接口(interface)(抽象类)和一组存储实现(SQLite、MySQL、Memcached..)，用于存储已知类的对象并从存储中检索子集。
对我来说，清晰的界面是:

class Storable{int id; blah; blah; blah; string type;};
class Storage{
    virtual Storage::iterator get_subset_of_type(string type) = 0;
    virtual Storage::iterator end)_ = 0;
    virtual void add_storable(Storable storable) = 0;
};

然后创建实现接口(interface)的 Storage 实现。现在，我的问题如下:

• 迭代器不能是多态的，因为它们按值返回。
• 我不能只为给定的 Storage 实现子类化 Storage::iterator
• 我考虑过使用一个包装器迭代器来包装 Storage 实现子类的多态类型并执行 pimpl，但随后我需要使用动态内存并在各处进行分配。

有什么提示吗？

Answer 1

如果你想要一个用于迭代的虚拟接口(interface)，是这样的吗？

#include <iostream>
#include <iterator>

struct Iterable {
    virtual int current() = 0;
    virtual void advance() = 0;
  protected:
    ~Iterable() {}
};

struct Iterator : std::iterator<std::input_iterator_tag,int> {
    struct Proxy {
        int value;
        Proxy(const Iterator &it) : value(*it) {}
        int operator*() { return value; }
    };
    Iterable *container;
    Iterator(Iterable *a) : container(a) {}
    int operator*() const { return container->current(); }
    Iterator &operator++() { container->advance(); return *this; }
    Proxy operator++(int) { Proxy cp(*this); ++*this; return cp; }
};

struct AbstractStorage : private Iterable {
    Iterator iterate() {
        return Iterator(this);
    }
    // presumably other virtual member functions...
    virtual ~AbstractStorage() {}
};

struct ConcreteStorage : AbstractStorage {
    int i;
    ConcreteStorage() : i(0) {}
    virtual int current() { return i; }
    virtual void advance() { i += 10; }
};

int main() {
    ConcreteStorage c;
    Iterator x = c.iterate();
    for (int i = 0; i < 10; ++i) {
        std::cout << *x++ << "\n";
    }
}

这不是一个完整的解决方案 - 我还没有实现 Iterator::operator== 或 Iterator::operator->(如果需要后者包含的类型是类类型)。

我将状态存储在 ConcreteStorage 类中，这意味着我们不能在同一个 Storage 上同时拥有多个迭代器。因此可能不是 Iterable 是 Storage 的基类，而是需要 Storage 的另一个虚函数来返回一个新的 Iterable。它只是一个输入迭代器这一事实意味着迭代器的拷贝都可以指向相同的 Iterable，因此可以使用 shared_ptr(以及 Itertable 应该有一个虚拟析构函数，或者 newIterator 函数应该返回 shared_ptr，或者两者兼而有之)。