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. }
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; }
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();

适用性

• 訪问一个集合对象的内容而无须要暴露它的内部展示
• 支持对集合对象的多种遍历
• 为遍历不同的集合结构提供一个统一的接口