自定義能夠for each的類，C#,Java,C++,C++/cli的實現方法

? ? ? 自定義類能夠被for each，應該算是個老生常談的話題了，相關的資料都很多，不過這里整理總結主流語言的不同實現方式，并比較部分細節上的差異。

? ? ? 第一種語言，也是實現起來最簡單的Java語言。在Java里，要被for each，就須實現Iterable<T>接口。Iterable<T>接口定義有一個方法（注：Java8以后多了兩個default方法，不用管他）：

Iterator<T> iterator();

? ? ??Iterator<T>接口下有三個方法：

boolean hasNext();
T next();

? ? ? 細節：迭代的第一次會先調用hasNext();方法，這一點跟后面有些語言不相同。

? ? ? 多說幾句，可能有些同學對Iterable<T>接口與Iterator<T>接口不一樣的地方是，Iterable<T>是容器類所實現的，Iterator<T>是迭代器。容器類是存放數據的，迭代器是存放迭代過程中的游標（當前訪問的位置），和控制游標和訪問器的移動的。

? ? ? 實現例子：

public class Person {
    private String name;
    public Person() {//構造函數
    }
    public String getName() {
        return name;
    }
}
public class PersonSet implements Iterable<Person>{
    private Person[] persons;//容器類存放數據，數組本身就可以被for each，只是這里演示如何使用Iterable<Person>接口。
    public PersonSet(){
        //構造函數
    }
    @Override
    public Iterator<Person> iterator() {
        // TODO Auto-generated method stub
        return new Iterator<Person>() {
            private int index=0;//迭代器存放游標
            @Override
            public boolean hasNext() {
                // TODO Auto-generated method stub
                return index < persons.Length;
            }

            @Override
            public Person next() {
                // TODO Auto-generated method stub
                return persons[index++];//別忘了訪問完數據還得移動游標
            }
        };
    }
}

? ? ? 遍歷方法：

PersonSet persons=//具體初始化過程不寫
for (Person person : persons)
{
    System.out.println(person.getName());
}

? ? ? 第二種語言，C#，跟JAVA相當類似，只是在迭代器的具體實現有些細節上的差異。Java是Iterable<T>，C#對應的接口叫IEnumerable<T>。IEnumerable<T>從非泛型的版本繼承，有兩個方法：

IEnumerator<T> GetEnumerator();
IEnumerator GetEnumerator();

? ? ? 與IEnumerable<T>相似，IEnumerator<T>接口也是從IEnumerator繼承，同時還繼承了IDisposable接口。其有3個方法和2個屬性：

T Current { get; }
object Current { get; }
void Dispose();
bool MoveNext();
void Reset();

? ? ? 方法和屬性較多，邏輯容易亂。不用愁，我來捋一下順序：

? ? ?第一次訪問：Reset()（初始化后游標被設置為空位置，不指向任何元素）->MoveNext()->Current

? ? ?第二次及以后訪問：MoveNext()->Current

? ? ?訪問退出：MoveNext()->Dispose()

? ? ? 具體實現：

class Person
{
    public string Name { get; }
}
class PersonSet:IEnumerable<Person>
{
    private Person[] persons;
    public PersonSet()
    {//構造函數
    }
    public IEnumerator<Person> GetEnumerator() => new Enumerator(this);

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();//顯式接口實現，直接返回泛型版本就可
    private class Enumerator : IEnumerator<Person>
    {
        private int index;
        private PersonSet parent;
        public Enumerator(PersonSet parent)
        {
            this.parent = parent;
        }
        public Person Current => parent.persons[index];

        object IEnumerator.Current => parent.persons[index];
        
        void IDisposable.Dispose() { }

        public bool MoveNext() => (++index) < parent.persons.Length;

        public void Reset() => index = -1;//游標一定要設為空！
        
    }
}

? ? ?調用方法：

PersonSet persons=//具體初始化過程不寫。
foreach(var person in persons)
{Console.WriteLine(person.Name);
}    

? ? ? 第三種方法，是C++/cli，其實C++/cli與C#都是基于.net的，C++/cli也一樣從IEnumerable<T>繼承，只是C++/cli不支持顯式接口實現，寫法有些差異。并且C++/cli語法啰嗦臃腫，順便給大家開眼界。一般不主張使用C++/cli，但是在混合使用C#和本地C++代碼時會很有用。另外，C++/cli的成員可以是非托管類的指針，但不能是對象本身（可能是因為托管對象會在內存移動，使得非托管類無法對自身成員進行取地址），C++/cli的泛型參數不能使非托管的，指針也不行。

頭文件：

#pragma once
ref class Person
{
public:
    property System::String^ Name { System::String^ get();}
};
ref class PersonSet : System::Collections::Generic::IEnumerable<Person^>
{
    ref class Enumerator : System::Collections::Generic::IEnumerator<Person^>
    {
    private:
        PersonSet^ parent;
    public:
        Enumerator();
        ~Enumerator();
        property Person^ Current{ virtual Person^ get(); };
        property Object^ NonGenericCurrent
        {
            virtual Object^ get() final = System::Collections::IEnumerator::Current::get;
            //通過重命名地方法來實現C#的“顯式接口調用”的效果。
        }
        virtual bool MoveNext();
        virtual void Reset();
    };
    array<Person^>^ persons;
public:
    PersonSet();
    virtual System::Collections::Generic::IEnumerator<Person^>^ GetEnumerator() final;
    virtual System::Collections::IEnumerator^ GetNonGenericEnumerator() final
        = System::Collections::IEnumerable::GetEnumerator;
    //通過重命名地方法來實現C#的“顯式接口調用”的效果。
};

CPP文件：（部分）

Person^ PersonSet::Enumerator::Current::get()
{
    return parent->persons[index];
}
Object^ PersonSet::Enumerator::NonGenericCurrent::get()
{
    return parent->persons[index];
}

bool PersonSet::Enumerator::MoveNext()
{
    return ++index < parent->persons->Length;
}

void PersonSet::Enumerator::Reset()
{
    index = -1;
}

System::Collections::Generic::IEnumerator<Person^>^ PersonSet::GetEnumerator()
{
    return gcnew Enumerator(this);
}

System::Collections::IEnumerator ^ PersonSet::GetNonGenericEnumerator()
{
    return GetEnumerator();
}

?

? ? ? ?調用方法：

PersonSet^ persons = gcnew PersonSet();
for each (auto person in persons)
{
    Console::WriteLine(person->Name);
}

? ? ? ?最后是非托管C++方式，非托管C++沒有接口這個概念，所以不存在要實現哪個接口的問題。事實上，C++11之前并沒有foreach(C++11里叫for range)，C++11要實現for range，需要實現以下五個函數：

iterator begin();//前兩個函數是容器類的成員，iterator是自行實現的迭代器，類名任意。
iterator end();
iterator& operator++();//后三個是迭代器的成員，操作符重載。
bool operator!=(iterator& other);
T operator*();//T是想要訪問的元素

? ? ? 調用順序：

? ? ?第一次訪問元素：?begin() ==> end() ==>?operator!=(iterator& other) ?==>?operator*()

? ? ?第二次即以后訪問元素：operator++() ==>?operator!=(iterator& other) ?==>?operator*()?

? ? ?訪問退出：operator++() ==>?operator!=(iterator& other)

? ? ? 注意的是：for range的迭代器游標初始化一定是指向首元素！實現方式：

頭文件：

struct NativePerson
{
    const char* name;
};
class PersonSet1
{
    NativePerson* const persons;
    const int length;
public:
    class iterator
    {
        PersonSet1* parent;
        int current;
    public:
        iterator(PersonSet1* parent,int current);
        iterator& operator++();
        bool operator!=(iterator& other);
        NativePerson operator*();
    };
    PersonSet1(NativePerson* const persons, int length);
    iterator begin();
    iterator end();
};

CPP文件：（部分）

PersonSet1::iterator & PersonSet1::iterator::operator++()
{
    current++;
    return *this;
}

bool PersonSet1::iterator::operator!=(iterator & other)
{
    return current < other.current;
}

NativePerson PersonSet1::iterator::operator*()
{
    return parent->persons[current];
}

PersonSet1::iterator PersonSet1::begin()
{
    return iterator(this,0);
}

PersonSet1::iterator PersonSet1::end()
{
    return iterator(this, length);
}

?? ? ?C++98的遍歷方式：

PersonSet1 ps(new NativePerson[10],10);
for (PersonSet1::iterator pp = ps.begin();pp != ps.end();pp++)
{
    cout << (*p).name << endl;
}

? ? ?C++11的遍歷方式：

PersonSet1 ps(new NativePerson[10],10);
for (auto p : ps)
{
    cout<<p.name<<endl;
}

? ? ?這里有個問題，按照要求，迭代器似乎必須知道最后一個元素，那對于只能遍歷，得等到遍歷到最后一個元素才能知道他的存在（沒有后繼），是否就沒法實現了呢？也不是，可以這么變通：begin()和end()不是各返回一個迭代器么，前者的游標會動，后者不動。給迭代器設置一個成員curPos，begin()返回的迭代器curPos為0，end()返回的迭代器curPos為1，然后當begin()的迭代器迭代到沒有沒有后繼時，把curPos設為1，然后不就能使得循環退出么？

? ? ?實現方法，假設有一個讀取NativePerson的讀取器，他長這樣的：

class PersonReader
{
public:
    bool next();
    NativePerson get();
};

? ? ?然后就可以這樣實現：

? ? ?頭文件：

class PersonSet2
{
    PersonReader& reader;
public:
    class iterator
    {
        PersonSet2& parent;
        CurPos curPos;
    public:
        iterator(PersonSet2& parent);//begin
        iterator();//end
        iterator& operator++();
        bool operator!=(iterator& other);
        NativePerson operator*();
    };
    PersonSet2(PersonReader& reader);
    iterator begin();
    iterator end();
};

CPP文件：（部分）

PersonSet2::iterator::iterator(PersonSet2 & parent) : parent(parent)
{
    curPos = BEGIN;
    operator++();//必須調用一次operator++()保證指針處在第一個元素。
}
PersonSet2::iterator::iterator() : parent(*(PersonSet2*)nullptr)
{
    curPos = END;
}

PersonSet2::iterator & PersonSet2::iterator::operator++()
{
    if (parent.reader.next())
    {
        //把讀取器的游標往后移動后要做的事
    }
    else
    {
        curPos = END;//這樣就把迭代器標記為末元素
    }
    return *this;
}

bool PersonSet2::iterator::operator!=(iterator & other)
{
    return curPos != other.curPos;//如果沒讀到最后一個元素，迭代器游標位置為BEGIN，否則就被設為END
}

NativePerson PersonSet2::iterator::operator*()
{
    return parent.reader.get();
}

PersonSet2::iterator PersonSet2::begin()
{
    return iterator(*this);
}

PersonSet2::iterator PersonSet2::end()
{
    return iterator();
}

然后就沒有然后了。還有什么問題么？

?