抽象类的快速灵活的迭代器

Question

为了以快速灵活的方式遍历数据网格，我设置了一个抽象的、模板化的 GridDataStructure 类。数据应该由 STL 迭代器访问。当有人使用该类时，他不应该担心哪种 STL 迭代器适合特定的子类。

这个问题的解决方案似乎是 使用迭代器隐藏内部容器并实现对基础容器的通用操作。但是，我不明白为什么 begin() 和 end() 成员不再是虚拟的。除此之外，我无法弄清楚 STL 迭代器类的必要方法（如operator++、operator* 等）到底应该在哪里实现。

请您看看我是否有设计错误？对我来说重要的是灵活的设计，但不以牺牲性能为代价。

我的班级设计：

template<class T>
class GridDataStructure
{
public:
    virtual iterator begin() = 0;
    virtual iterator end() = 0;
};

template<class T>
class GridDataUniform : GridDataStructure
{
public:
    GridDataUniform(int size);        

    iterator begin();
    iterator end();

    class iterator : public std::iterator<std::forward_iterator_tag, T> {
    public:
      iterator(Node* p) : node_(p) {}
      ~iterator() {}

      iterator& operator=(const iterator& other);
      bool operator==(const iterator& other);
      bool operator!=(const iterator& other);
      iterator& operator++();
      iterator& operator++(int);
      T& operator*();
      T* operator->();

    private:
      Node* node_;
    };

    private:
        T* griddata;
};

我想以 STL 风格访问我的网格容器，例如：

GridDataStructure<int>::iterator = someGrid->begin(); // where someGrid is an instance of GridDataUniform
std::cout << *(iter) << std::endl;

非常感谢任何帮助。

编辑（10.10.19）：添加了嵌套迭代器类

编辑（10.10.20）：添加了代码：

template<class T>
class GridDataStructureBase
{
protected:
class BaseIteratorImpl
{
    virtual iterator begin() = 0;
    virtual iterator end() = 0;
    virtual iterator& operator++() = 0;
}

public:
class iterator : std::iterator<std::forward_iterator_tag, T>
{
public:
    iterator(const BaseIteratorImpl& itImpl) {}
    iterator begin() { return itImpl->begin(); }
    iterator end() { return itImpl->end(); }
    iterator& operator++() { return itImpl->operator++() }

private:
    BaseIteratorImpl* itImpl;

};

iterator begin()
{
    iterator* i = new iterator(??);
    return i->begin();
}

iterator end()
{
    return iterator(NULL);
}

};

Answer 1

在该解决方案中，begin 和 end 不需要是虚拟的，因为它们只是调用虚拟的 BaseIteratorImpl::begin 和 BaseIteratorImpl::end 。

在您的具体情况下，您可以将 begin 和 end 设为虚拟，而不进行任何转发，它将能够执行您想要的操作。您指出的解决方案是，如果您想要在同一结构上使用不同样式的迭代器，而不仅仅是您想要的结构-迭代器配对。

编辑：这里有一些东西可以开始（未经测试或什至编译） - 可能不会编译并且会泄漏（编写析构函数，复制因子，op=，你需要的地方） - 只是为了让你开始这个想法。

template <class T>
class GridIteratorImplBase {
   public:
      virtual GridIteratorImplBase<T>& operator++() = 0;
      virtual T& operator*() = 0;
};

template <class T>
class GridIterator {
   private:
      GridIteratorImplBase<T> *baseImpl;
   public:
      GridIterator(GridIteratorImplBase<T> *b) :baseImpl(b) {}
      GridIterator& operator++() { baseImpl->operator++(); return *this;}
      T& operator*() { return baseImpl->operator*(); }


  // you need to write a dtor, copy ctor and op= or this will leak
  // copy ctor and op= need to make new objects that are copies of baseImpl, dtor needs to delete -- make sure not to share baseImpl between two GridIterator objects
};


template <class T>
class Grid {
   virtual GridIterator<T> begin() = 0;
   virtual GridIterator<T> end() = 0;
};


template <class T>
class GridUniform {

  template <class T>
  class GridUniformIterator : GridIteratorImplBase<T>
      private T* current;
   public:
      GridUniformIterator(T* c) : current(c) {}
      virtual GridIteratorImplBase<T>& operator++() { current++; return *this; }
      virtual T& operator*() { return *current; }
  };

  GridIterator<T> begin() { 
      GridIterator<T> iter(new GridUniformIterator(gridData)); 
      return iter; 
  }
  GridIterator<T> end() { 
      GridIterator<T> iter(new GridUniformIterator(gridData+size));
      return iter; 
  }


  private:
    T* gridData;
    int size;
};

我直接将其输入到此答案的文本区域中 - 而不是编译器。它旨在为您提供想法，以便您可以开始。

1. begin 和 end 应该创建迭代器，
2. 迭代器需要能够被复制构造并对其调用operator=。如果你尝试为它们建立一个基类，它们将被强制转换为基类，因此你不能为它们使用 virtual
3. 为了解决第 2 个问题，你可以让迭代器只保留一个指向迭代器实现的基类的指针。