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

Iterator - 迭代器模式

2024-07-13 03:02:49   227人阅读

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

案例
一个聚合对象，如一个列表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. }
  7. 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.    
  7.     Iterator<Item>* operator->() { returm m_iter; }
  8.     Iterator<Item>* operator*() { return *m_iter; }
  10. private:
  11.     Iterator<Item>* m_iter;
  12. }
  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();
  7. proteced:
  8.     virtual void processItem(const Item&) = 0;
  10. private:
  11.     IteratorOne<Item> m_iter;
  12. };
  14. void ListTraverser::traverse() {
  15.     bool result = false;
  16.     for(m_iter.first(); !m_iter.isEnd(); m_iter.next()) {
  17.         processItem(m_item.current());
  18.     }
  19. }
如果是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();
适用性
  • 访问一个集合对象的内容而无需要暴露它的内部展示
  • 支持对集合对象的多种遍历
  • 为遍历不同的集合结构提供一个统一的接口


联系
我们