定義

迭代器模式（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）：具體實現對某種聚合對象的遍歷。

優缺點

優點

1. 支持以不同的方式遍歷一個聚合對象。如二叉樹就可以有前序遍歷、中序遍歷、後序遍歷、層序遍歷等多種遍歷方式。

2. 迭代器簡化了聚合類。聚合類內部就不需要再去實現遍歷方法了。

3. 由於引入了抽象層，增加新的聚合類和迭代器類都很方便，無須修改原有代碼，符合開閉原則。

缺點

1. 增加一種聚合類就要至少增加一種迭代器類，增加了系統的複雜性。

使用場景

1. 在不暴露聚合對象的底層表示的前提下遍歷聚合對象。

2. 需要為聚合對象提供多種遍歷方式。

3. 為遍歷不同的聚合結構提供一個統一的介面。