一、迭代器概述

  這個標題其實有點“標題黨”的含義，因為C++在標準庫中的實現迭代器的方式只有一種，也就是為類定義begin()和end()函式，C++11增加了range for語句，可以用來遍歷迭代器中的元素。實現迭代器的第二種方式，就是用C++模擬C#和Java中的迭代器模式，並且我們可以定義出自己的foreach語句。除此之外，迭代器可能還有很多種實現的方法，各個庫也會多自己的迭代器的實現有所定義，在這裡只要明白迭代器的本質意義即可。

  迭代器，也稱作遊標，是一種設計模式，我們可以對它進行遞增（或選擇下一個）來訪問容器中的元素，而無需知道它內部是如何實現的。

  很多語言提供foreach語句來訪問容器中的每一個元素，其實也就是呼叫容器中的迭代器，抽象地來說就是：

  foreach ( 元素 : 容器 ) { ... }

  上面的程式碼等效於：

  for ( 遊標=獲得迭代器的開頭，獲得迭代器的末尾; 遊標 != 迭代器末尾; 遊標移動一個單位 ) {...} // C++ 的迭代器模式

  或者：

  while ( 迭代器遊標移動一個單位（返回是否存在下一個單位）) { ... } // C#、Java的迭代器模式，可以用迭代器.Current之類的方法返回遊標所指向的元素

二、C++中的迭代器實現方式

  迭代器其實是一個類，要自定義一個迭代器，就要過載迭代器的!=、解引用(*)、++運算子，以便它在range for語句中使用。range for 是C++11中新增的語句，如我們對一個集合使用語句for (auto i : collection ) 時，它的含義其實為：

for ( auto __begin = collection.begin(), auto __end = collection.end(); __begin != __end(); ++__begin ) 
{ i = *__begin; 
	... //迴圈體 
}
 

  begin和end是集合的成員函式，它返回一個迭代器。如果讓一個類可以有range for的操作，它必須：   · 擁有begin和end函式，它們均返回迭代器   · end函式返回一個指向集合末尾，但是不包含末尾元素的值，即用集合範圍來表示，一個迭代器的範圍是 [ begin, end ) 一個左閉右開區間   對於迭代器，它的要求至少是：   · 必須過載++、!=和解引用（*）運算子；迭代器看起來會像一個指標   · 迭代器必須可以通過++最後滿足!=條件，這樣才能夠終止迴圈   下面給出最簡單的實現程式碼。我們定義一個CPPCollection類，裡面有個字串陣列，我們讓它能夠通過range for將每個字串輸出來。

#include <iostream>

class CPPCollection {
public:
    class Iterator{
    public:
        int index;
        CPPCollection& outer;
        Iterator(CPPCollection &o, int i) : outer(o), index(i) { }
        void operator++(){
            index++;
        }
        std::string operator*() const{
            return outer.str[index];
        }
        bool operator !=(Iterator i){
            return i.index != index - 1;
        }
    };
public:
    std::string str[10] {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
    Iterator begin() {
        return Iterator(*this, 0);
    }
    Iterator end() {
        return Iterator(*this, 9);
    }
};
 

  我們定義了個內部的巢狀類Iterator，併為它過載了++、*、!=運算子。由於C++中的內部巢狀類與外圍的類沒有聯絡，為了訪問外部類物件的值，我們必須要傳入一個引用（或指標，本例中傳入引用）。Iterator的自增方法其實就是增加內部的一個索引值。判斷!=的方法是和另外一個迭代器做比較，這個迭代器一般是集合的末尾，當我們的索引值不等於末尾的索引值-1（ [begin, end) ）時，認為迭代器已經達到了末尾。   在CPPCollection類中，定義了begin()、end()分別返回開頭、結束迭代器，呼叫如下程式碼：

    CPPCollection cpc;
    for (auto i : cpc){
        std::cout << i << std::endl;
    }

  即可遍歷集合中的所有元素了。
  在泛型演算法中，為了對集合中的每一個元素進行操作，我們通常要傳入集合的迭代器頭、迭代器尾，以及謂詞，例如std::find_if(vec.begin(), vec.end(), ...)，這種泛型演算法其實就是在迭代器的首位反覆迭代，然後執行相應的行為。

三、模擬C#（Java）中的迭代器實現方式

  C#和Java的迭代器實現方式較為類似，在這裡以C#為例，我用C++來模擬它的實現。C#中，可迭代的類繼承IEnumerable介面，它聲明瞭一個方法GetEnumerator，返回一個迭代器。迭代器繼承IEnumerator介面，介面定義了MoveNext()方法：將遊標移動一個單位，並返回是否還可以移動；Reset()方法：遊標歸位; Current屬性：返回當前遊標所指向的值（在C#中，Current是一個屬性，為了模擬它，在C++中將它定義為一個函式），並且用只包含抽象函式的類來模擬介面：

#define interface struct
template <typename T>
interface IEnumerator {
    virtual T& Current() = 0;
    virtual bool MoveNext() = 0;
    virtual void Reset() = 0;
    virtual ~IEnumerator<T>() { };
};


template <typename T>
interface IEnumerable {
    virtual IEnumerator<T>& GetEnumerator() = 0;
    virtual ~IEnumerable () { };
};

為了自定義一個foreach“關鍵字”，可以用巨集定義來進行迭代器的等效替代：

#define foreach(item, collection)                                           \
auto &__item_enumerator = collection.GetEnumerator();                       \
__item_enumerator.Reset();                                                  \
while (item = __item_enumerator.Current(), __item_enumerator.MoveNext())

  當我們使用foreach的時候，巨集展開自動展開為呼叫集合類collection的GetEnumerator()函式來獲得一個迭代器的引用，復位之，並將當前值賦予item，迭代器向前移動。需要注意的是，我們在程式碼中不能重複定義__item_enumerator變數，且型別一定要為auto&：auto變數不會保留引用符號，且如果不是引用（或指標），會觸發拷貝建構函式，從而失去物件的多型性。   如同剛才一樣，我們定義一個集合類：

class CSharpCollection : public IEnumerable<std::string>{
public:
    class Enumerator : public IEnumerator<std::string> {
    public:
        CSharpCollection &outer;    //外部類
        int index = 0;  //下標
        Enumerator (CSharpCollection &o) : outer(o){
        }
        bool MoveNext() override {
            index++;
            if (index <= 10) return true;
            delete this;
            return false;
        }
        void Reset() override {
            index = 0;
        }
        std::string &Current() override {
            return outer.str[index];
        }
        ~Enumerator (){
            std::cout << "Enumerator 被析構" << std::endl;
        }
    };
public:
    std::string str[10] {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"};
    IEnumerator<std::string>& GetEnumerator() override{
        return *new Enumerator(*this);
    }
};

  需要注意的是，凡是體現多型性的函式，返回值必須為引用或者指標，且不得為棧中的臨時變數，因此我們呼叫完GetEnumerator()後，要將生成的迭代器刪除，刪除的程式碼寫在了MoveNext()內，當遊標不可移動的時候，迭代器被刪除。

  以後就可以用自己的foreach巨集定義來遍歷元素了：

    std::string a;
    CSharpCollection csc;
    IEnumerable<std::string>& refcsc = csc;
    foreach (a , refcsc ){
        std::cout << a << std::endl;
    }

  上面程式碼的第三行意在說明，如果一個類中繼承了IEnumerable類，它一定是可迭代的，可以呼叫它的Reset()、MoveNext()、Current()，也可以用我們剛剛寫的foreach來進行遍歷。