定義 迭代器模式（Iterator pattern）：用於順序訪問集合對象里的每一個元素，不用暴露集合是怎樣存儲元素的。 舉例 某個班級有若幹個學生，現在需要統計這些學生的平均分數。假設所有學生的分數是用數組存儲的： int totalScore(int *array, int n) { int s ...
定義
迭代器模式（Iterator pattern）：用於順序訪問集合對象里的每一個元素，不用暴露集合是怎樣存儲元素的。
舉例
某個班級有若幹個學生，現在需要統計這些學生的平均分數。假設所有學生的分數是用數組存儲的：
int totalScore(int *array, int n)
{
int sum = 0;
for (int i = 0; i < n; i++) // 遍曆數組
{
sum += array[i];
}
return sum;
}
但是，如果是用鏈表存儲呢？就要重新寫一套邏輯來遍歷鏈表。那有沒有一種方法，無論分數是如何存儲的，都可以有統一的方式進行遍歷呢？
答案是將“存儲”與“遍歷”解耦，先創建抽象的Collection和Iterator兩個介面，再分別派生出具體的聚合對象和迭代器。遍歷時，由迭代器來負責遍歷，而不是由聚合對象負責遍歷。
UML類圖：
代碼：
抽象聚合類：
template <typename T>
class AbstractCollection
{
public:
virtual ~AbstractCollection() = default;
};
具體聚合類（數組、單向鏈表）：
template <typename T>
class Array : public AbstractCollection<T>
{
friend class ArrayIterator<T>;
T *start;
int n;
public:
Array(T *start, int n) : start(start), n(n) { }
ArrayIterator<T> getIterator()
{
return ArrayIterator<T>(*this);
}
T &operator[](int i)
{
return start[i];
}
};
template <typename T>
class LinkedList : public AbstractCollection<T>
{
friend class ListNodeIterator<T>;
/*
本例中單向鏈表的首節點之前有哨兵節點（sentinel)，尾結點的後一個節點為nullptr
*/
struct ListNode
{
T data;
ListNode *next;
};
ListNode *sentinel;
public:
LinkedList(ListNode *sentinel) : sentinel(sentinel) { }
ListNodeIterator<T> getIterator()
{
return ListNodeIterator<T>(*this);
}
};
抽象迭代器類：
template <typename T>
class AbstractIterator
{
public:
virtual ~AbstractIterator() = default;
virtual bool hasNext() = 0;
virtual T &next() = 0;
};
具體迭代器類：
template <typename T>
class ArrayIterator : public AbstractIterator<T>
{
Array<T> &array;
int i;
public:
ArrayIterator(Array<T> &array) : array(array), i(-1) { }
bool hasNext() override
{
return i + 1 < array.n;
}
T &next() override
{
++i;
return array[i];
}
};
template <typename T>
class LinkedListIterator : public AbstractIterator<T>
{
LinkedList<T> &list;
LinkedList::ListNode *current;
public:
LinkedListIterator(LinkedList<T> &list) : list(list), current(list.sentinel) { }
bool hasNext() override
{
return current->next != nullptr;
}
T &next() override
{
current = current->next;
return current->data;
}
};
客戶端：
class Client
{
public:
void testArray()
{
Array<int> array( /* 初始化部分省略 */ );
int sum = 0;
for (auto iterator = array.getIterator(); iterator.hasNext(); )
{
sum += iterator.next();
}
cout << sum << endl;
}
void testLinkedList()
{
LinkedList<int> list( /* 初始化部分省略 */ );
int sum = 0;
for (auto iterator = list.getIterator(); iterator.hasNext(); )
{
sum += iterator.next();
}
cout << sum << endl;
}
};
可以看到，遍歷部分的代碼是完全一樣的。這正是因為我們給不同的遍歷方式提供了統一的介面。
組成部分
抽象聚合類（Abstract Collection）：存儲數據的抽象類，持有迭代器對象。
具體聚合類（Concrete Collection）：具體實現數據的存儲。
抽象迭代器類（Abstract Iterator）：定義判斷是否有下一個元素和返回下一個元素的抽象介面。
具體迭代器類（Concrete Iterator）：具體實現對某種聚合對象的遍歷。
優缺點
優點
-
支持以不同的方式遍歷一個聚合對象。如二叉樹就可以有前序遍歷、中序遍歷、後序遍歷、層序遍歷等多種遍歷方式。
-
迭代器簡化了聚合類。聚合類內部就不需要再去實現遍歷方法了。
-
由於引入了抽象層，增加新的聚合類和迭代器類都很方便，無須修改原有代碼，符合開閉原則。
缺點
- 增加一種聚合類就要至少增加一種迭代器類，增加了系統的複雜性。
使用場景
-
在不暴露聚合對象的底層表示的前提下遍歷聚合對象。
-
需要為聚合對象提供多種遍歷方式。
-
為遍歷不同的聚合結構提供一個統一的介面。
