迭代器模式

2020-12-20

意图:提供一种方法顺序访问一个组合对象中的各个元素，而又不需要暴露该对象的内部表示。

动机:在软件构建过程中，集合对象内部结构常常变化各异，但对于这些集合对象，我们希望在不暴露其内部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这个“透明遍历”也为“同一种算法在多种集合对象上进行操作”提供了可能。

适用性:

访问一个集合对象的内容而无需暴露它的内部表示
支持聚合对象的多种遍历
为遍历不同的聚合结构提供一个统一的接口

结构：

参与者：

Iterator: 迭代器定义访问和遍历元素的接口

ConcreteIterator : 具体迭代器实现迭代器接口；对该聚合遍历时跟踪当前位置

Aggregate: 聚合定义创建相应的迭代器

ConcreteAffregate : 具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例

协作：

ConcreteIterator跟踪聚合中的当前对象，并能够计算出待遍历的后继对象。

效果：

支持以不同的方式遍历一个聚合
简化了聚合的接口
在同一个聚合上可以有多个遍历

实现：

代码示例如下：

#include <iostream>
#include <vector>
//抽象迭代器声明
template <typename T> class Iterator;
//抽象聚合
template <typename  T>
class Aggregate{
public:
  virtual ~Aggregate(){}
  virtual Iterator<T>* GetIterator() = 0;
  virtual int size() const = 0;
  virtual const T&operator[](size_t index) const = 0;
  virtual void AddItem(T const& t) = 0;

protected:
  Aggregate(){}
};
//抽象迭代器定义接口
template <typename  T>
class Iterator{
public:
  virtual ~Iterator(){}
  virtual void first() = 0;
  virtual void Next() = 0;
  virtual bool IsDone() = 0;
  virtual const T& operator*()  const = 0;
  friend std::ostream&operator<<(std::ostream& os,Iterator& t){
    os << *t;
    return os;
  }
protected:
  Iterator(){}
};
//具体的迭代器
template <typename T>
class ConcreteIterator : public Iterator<T>{
public:
  ConcreteIterator(Aggregate<T>* agg) : _aggregate(agg),current_(0){}
  ~ConcreteIterator(){}
  void first(){
    current_ = 0;
  }
  bool IsDone(){ return current_ >= _aggregate->size();}
  void Next(){
    if (current_ < _aggregate->size()){
      current_ ++;
    }
  }
  const T& operator*()  const{
    if(current_ <= _aggregate->size()){
      return (*_aggregate)[current_];
    }else{
      throw  std::logic_error("index overflow");
    }
  }

private:
  Aggregate<T>* _aggregate;
  size_t current_;
};
//具体聚合
template <typename  T>
class  ConcreteAggregate : public Aggregate<T>{
public:
  ConcreteAggregate(){}
  ~ConcreteAggregate(){}
  Iterator<T>* GetIterator(){
    return new ConcreteIterator<T>(this);
  }
  int size() const {
    return _items.size();
  }
  void AddItem(T const& t){
    _items.emplace_back(t);
  }
  const T& operator[](size_t index) const{
    if (index >= 0 && index < _items.size()){
      return _items[index];
    }else{
      throw std::logic_error("error for index");
    }
  }
private:
  std::vector<T> _items;
};
//测试使用
int main(int argc,char *argv[]) {
  ConcreteAggregate<int> aggtest;
  for (int i = 0; i <10 ; ++i) {
    aggtest.AddItem(i);
  }
  Iterator<int> *it = aggtest.GetIterator();
  for (it->first();!it->IsDone();it->Next()) {
    std::cout << " " << *it << "\t";
  }
  return 0;
}