首页 > 代码库 > Iterator - 迭代器模式

Iterator - 迭代器模式

定义
提供一个方法顺序访问一个聚合对象中个各个元素,而又不需要暴露该对象的内部结构。

案例
一个聚合对象,如一个列表List,应该提供一种方法来让别人可以访问它的元素,而又不用暴露内部结构。迭代器模式可以很好的解决这类问题,关键思想就是将队列表的访问和遍历从列表对象中分离出来,放到一个迭代器Iterator对象中,Iterator定义了一个访问List对象的接口。


AbstractList提供了List的基本接口:
  1. template<class Item>
  2. class AbstractList {
  3. public:
  4. virtual Iterator* createIterator() const = 0;
  5. virtual int count() const = 0;
  6. virtual void append(Item item) = 0;
  7. virtual void remove(Item item) = 0;
  8. virtual void get(Int index) = 0;
  9. };
在其子类中实现相关操作:
  1. template<class Item>
  2. class ListOne : public AbstractList {
  3. public:
  4. virtual Iterator* createIterator() const;
  5. ...
  6. };
  7. Iterator* ListOne::createIterator() {
  8. return new IteratorOne<Item>(this);
  9. }
Iterator类提供公有接口来支持迭代:
  1. template<class Item>
  2. class Iterator {
  3. public:
  4. virtual void first() = 0;
  5. virtual void next() = 0;
  6. virtual bool isEnd() const = 0;
  7. virtual Item current() const = 0;
  8. proteced:
  9. Iterator();
  10. };
子类进行具体操作的实现:
  1. template<class Item>
  2. class IteratorOne : public Iterator {
  3. public:
  4. IteratorOne(const ListOne<Item>* list);
  5. virtual void first();
  6. virtual void next();
  7. virtual bool isEnd() const;
  8. virtual Item current() const;
  9. private:
  10. ListOne<Item>* m_list;
  11. int m_index;
  12. };
  13. template<class Item>
  14. void IteratorOne::first() {
  15. m_index = 0;
  16. }
  17. template<class Item>
  18. void IteratorOne::next() {
  19. ++m_index;
  20. }
  21. template<class Item>
  22. bool IteratorOne::isEnd() const {
  23. return m_index == m_list->count();
  24. }
  25. tempalte<class Item>
  26. Item IteratorOne::current() const {
  27. if(isEnd())
  28. throw IteratorOutOfBounds();
  29. return m_list->get(m_index);
  30. }
比如现在我们要打印Book类的一个List的书名:
  1. ListOne<Book*> books;
  2. IteratorOne<Book*>* iter = books.createIterator();
  3. for(iter->first(); !iter->isEnd(); iter->next()) {
  4. std::cout << iter->current()->print();
  5. }
  6. delete iter;
这样实现必须保证每次迭代器都被删除,可以定义一个IteratorPtr来确保对象被释放:
  1. template<class Item>
  2. class IteratorPtr {
  3. public:
  4. IteratorPtr(Iterator<Item>* iter) : m_iter(iter) {}
  5. ~IteratorPtr() { delete m_iter; }
  6. Iterator<Item>* operator->() { returm m_iter; }
  7. Iterator<Item>* operator*() { return *m_iter; }
  8. private:
  9. Iterator<Item>* m_iter;
  10. }
  1. ListOne<Book*> books;
  2. IteratorPtr<Book*> iter(books.createIterator());
  3. for(iter->first(); !iter->isEnd(); iter->next()) {
  4. std::cout << iter->current()->print();
  5. }
以上是迭代器的一种外部实现方式,还有一种内部实现方式:
  1. template<class Item>
  2. class ListTraverser {
  3. public:
  4. ListTravrerser(ListOne<Item>* list);
  5. void traverse();
  6. proteced:
  7. virtual void processItem(const Item&) = 0;
  8. private:
  9. IteratorOne<Item> m_iter;
  10. };
  11. void ListTraverser::traverse() {
  12. bool result = false;
  13. for(m_iter.first(); !m_iter.isEnd(); m_iter.next()) {
  14. processItem(m_item.current());
  15. }
  16. }
如果是Book对象的迭代操作,就可以定义一个BookTraverser类,实现processItem函数:
  1. void BookTraverse::processItem(const Book* book) {
  2. cout << book;
  3. }
  1. List<Book> books;
  2. BookTraverse bt(books);
  3. bt.traverse();
适用性
  • 访问一个集合对象的内容而无需要暴露它的内部展示
  • 支持对集合对象的多种遍历
  • 为遍历不同的集合结构提供一个统一的接口