自制迭代器的const正确性

总体目标

我管理一个对象集合(Real的Collection作为简单的例子)。然后在集合上定义迭代器。即:iterator, const_iterator, reverse_iterator, const_reverse_iterator。在这个例子中，我将只关注iterator和const_iterator，另外两个非常相似。

之后，我想在集合上定义一个过滤器，它根据特定条件保留或不保留元素。例如，只保留具有正值的Real实例。我还想只在保留的元素上迭代我的集合。

如何实现集合

对于本例，集合中的对象非常简单。我们的目标只是拥有一个对象而不是原生类型:

struct Real
{
    public:
      double r;
};

然后我定义我的集合，而不需要知道里面真正的容器:

class Collection
{
  public:
    typedef std::vector<Real>::iterator iterator;
    typedef std::vector<Real>::const_iterator const_iterator;
  private:
    std::vector<Real> data;
  public:
    Collection() : data() {}
    Collection(unsigned long int n) : data(n) {}
    Collection(unsigned long int n, const Real& x) : data(n,x) {}
    Collection::iterator       begin()       { return this->data.begin(); }
    Collection::iterator       end()         { return this->data.end(); }
    Collection::const_iterator begin() const { return this->data.begin(); }
    Collection::const_iterator end() const   { return this->data.end(); }
};

这在这个简单的例子中运行得非常好:

int main()
{
  Collection c(5);
  double k = 1.0;
  for(Collection::iterator it = c.begin(); it != c.end(); ++it)
  {
    it->r = k;
    k *= -2.0;
  }
  std::cout << "print c with Collection::iterator" << std::endl;
  for(Collection::iterator it = c.begin(); it != c.end(); ++it)
    std::cout << it->r << std::endl;
  std::cout << "print c with Collection::const_iterator" << std::endl;
  for(Collection::const_iterator it = c.begin(); it != c.end(); ++it)
    std::cout << it->r << std::endl;
  return 0;
}

这个程序写出预期的输出:

print with Collection::iterator
1
-2
4
-8
16
print with Collection::const_iterator
1
-2
4
-8
16

如何实现过滤器

现在我想创建一个抽象过滤器，它有一个指向集合的引用或指针，有迭代器，还有一个通过过滤器接受值的抽象函数。对于第一步，我只编写了没有迭代器的类:

class CollectionFilter
{
  private:
    Collection& col;
  public:
    CollectionFilter(Collection& c) : col(c) {}
    virtual ~CollectionFilter() {}
    Collection& collection() { return this->col; }
    iterator begin() { /* todo */ }
    iterator end() { /* todo */ }
    const_iterator begin() const { /* todo */ }
    const_iterator end() const { /* todo */ }
    virtual bool accept(const Real& x) const = 0;
};

然后，很容易创建一个新的过滤器来实现特定的条件:

class CollectionFilterPositive : public CollectionFilter
{
  public:
    CollectionFilterPositive(Collection& c) : CollectionFilter(c) {}
    virtual ~CollectionFilterPositive() {}
    virtual bool accept(const Real& x) const { return x.r >= 0.0; }
};

在实现过滤器中的迭代器之前，我有一些备注/问题。

1. 此过滤器适用于非const Collection&，那么，begin() const和end() const功能真的需要吗?如果是，为什么?
2. 我不能在const Collection&上应用过滤器，但它显然是我的目标所必需的。有什么好办法呢?我是否需要将类CollectionFilter复制到具有非常相似代码的类CollectionFilterConst ?此外，这种解决方案对于必须从两个类似的类继承的用户来说是相当混乱的。

然后，让我们看看迭代器的实现。对于本例，我只编写了iterator而没有编写const_iterator。我将这个添加到我的类中:

class CollectionFilter
{
  public:
    class iterator
    {
      private:
        CollectionFilter*    filter;
        Collection::iterator iter;
      public:
                  iterator(CollectionFilter* f, Collection::iterator i) : filter(f), iter(i) {}
                  iterator(const iterator& i) : filter(i.filter), iter(i.iter) {}
        iterator& operator = (const iterator& i) { this->filter = i.filter; this->iter = i.iter; return *this; }
        iterator& operator ++ ()
        {
          if(this->iter != this->filter->collection().end())
          {
            do
            {
              ++this->iter;
            } while(this->iter != this->filter->collection().end() && !this->filter->accept(*this->iter));
          }
        }
        iterator operator ++ (int) { /* similar */ }
        Real& operator * () { return *this->iter; }
        Collection::iterator operator -> () { return this->iter; }
        bool operator == (const iterator& i) const { return this->iter == i.iter; }
        bool operator != (const iterator& i) const { return this->iter != i.iter; }
    };
  public:
    iterator begin()
    {
      Collection::iterator it = this->col.begin();
      if(!this->accept(*it)) ++it;
      return CollectionFilter::iterator(this,it);
    }
    iterator end()
    {
      Collection::iterator it = this->col.end();
      return CollectionFilter::iterator(this,it);
    }
};

这在这个简单的例子

int main()
{
  Collection c(5);
  double k = 1.0;
  for(Collection::iterator it = c.begin(); it != c.end(); ++it)
  {
    it->r = k;
    k *= -2.0;
  }
  std::cout << "print c with CollectionFilterPositive::iterator" << std::endl;  
  CollectionFilterPositive fc(c);
  for(CollectionFilterPositive::iterator it = fc.begin(); it != fc.end(); ++it)
    std::cout << it->r << std::endl;
  return 0;
}

给出预期输出:

print with CollectionFilterPositive::iterator
1
4
16

还有一些问题: