Java, C++, C++ CLI , C# 的迭代

C++ 

/// <summary>
///  C#语句：public class DList<T> : IEnumerable
/// </summary>
/// <typeparam name="T"></typeparam>
template<typename T> 
class DList
{
protected:
    DListNote_<T>* _First;         //第一个节点
    DListNote_<T>* _Last;         //最后一个节点
    size_t  _Count;                 //节点个数
    size_t _MaxBuffer;           //双链表最大可以存储的元素个数
    sortord_ _Sortord;           //排序顺序
    
public:

   inline DListNoteIterator_<T> begin()const { return DListNoteIterator_<T>(_First); }

｝

template<typename T>
class DListNoteIterator_
{
private:
    DListNote_<T>* _pNote;
public:
    /// <summary>
    /// 构造函数，传值迭代器管理的值
    /// </summary>
    /// <param name="pNote"></param>
    inline DListNoteIterator_(DListNote_<T>* pNote)
    {
        //::System::Windows::Forms::MessageBox::Show(L"inline LDIterator(DListNote_<T>* pNote)");
        _pNote = pNote;
    }


    /// <summary>
    /// 比较实现
    /// </summary>
    /// <param name="that"></param>
    /// <returns></returns>
    bool operator != (const DListNoteIterator_& that)
    {
        //::System::Windows::Forms::MessageBox::Show(L"bool operator != (const LDIterator& that)");

        return _pNote != that._pNote;
    }


    /// <summary>
    /// 自增实现
    /// </summary>
    /// <returns></returns>
    inline DListNoteIterator_& operator ++ ()
    {
        //::System::Windows::Forms::MessageBox::Show(L"inline DListNoteIterator_& operator ++ ()");

        _pNote = _pNote->Next;

        return *this;
    }

    //解引用，取值
    T& operator * ()
    {
        //::System::Windows::Forms::MessageBox::Show(L"T& operator * ()");
        return _pNote->Data;
    }

    //LDIterator(const LDIterator&) = delete;
    //LDIterator& operator=(const LDIterator&) = delete;
    //~LDIterator() = default;
};

C++  CLI

 

/// <summary>
/// 双向链表 //where T : List<T>, IComparable<T>
/// </summary>
/// <typeparam name="T"></typeparam> 
template<class T>
ref class csharp_DList : IEnumerable
{
    protected:
        csharp_DListNote<T>^ _First;        //第一个节点
        csharp_DListNote<T>^ _Last;            //最后一个节点
        int  _Count;                        //节点个数     
        Sortord_ _sortord;                  //排序顺序

    public:

        //--------------------------------------------------------------------------接口

        /// <summary>
        //示例为了使一个类支持集合初始化器，它必须实现IEnumerable接口并至少具有一个Add方法。从C＃6开始，
        //IEnumerable可以Add使用扩展方法使用自定义方法扩展任何实现的集合。
        /// </summary>
        /// 创建时间：2020-05-07  最后一次修改时间： 2020-05-07
        /// <returns></returns>
        virtual  IEnumerator^ GetEnumerator()
        { 
            return  gcnew csharp_DListNoteEnum_<T>(_First);
        }
 }

        /// <summary>
        /// 节点数据的foreach迭代
        /// </summary>
        /// 创建时间：2020-05-07  最后一次修改时间： 2020-05-07
        /// <typeparam name="T"></typeparam>
        template<class T>
        ref class csharp_DListNoteEnum_ : IEnumerator
        {
        private:
            csharp_DListNote<T>^ _dn;
            csharp_DListNote<T>^ _dnCurr;
            int _iIndex;

        public:
            csharp_DListNoteEnum_(csharp_DListNote<T>^ dn)
            {
                _dn = dn;
                _iIndex = -1;
            }


            /// <summary>
            /// IEnumerator最终调用的是这个函数访问
            /// </summary>
            virtual property Object^ Current
            {
                Object^ get() {
                    return _dnCurr-> Data;
                }
            }


            virtual bool MoveNext()
            {
                ++ _iIndex; //指针首先向前移动一位

                if (_dnCurr == null){
                    _dnCurr = _dn;
                }else{ 
                    _dnCurr = _dnCurr-> Next;
                }
                return _dnCurr != null;
            }

            virtual void Reset()
            {
                _dnCurr = null;

                _iIndex = -1;
            }

             
        };

c#

     /// <summary>
    /// 双向链表
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class DList_<T> : IEnumerable
    {

        protected DListNote_<T> _First;                    //第一个节点
        protected DListNote_<T> _Last;                    //最后一个节点
        protected int  _Count;                            //节点个数     
        protected Sortord_ _sortord;                    //排序顺序

        //--------------------------------------------------------------------------接口

        /// <summary>
        //示例为了使一个类支持集合初始化器，它必须实现IEnumerable接口并至少具有一个Add方法。从C＃6开始，
        //IEnumerable可以Add使用扩展方法使用自定义方法扩展任何实现的集合。
        /// </summary>
        /// 创建时间：2020-05-07  最后一次修改时间： 2020-05-07
        /// <returns></returns>
        public IEnumerator GetEnumerator()
        { 
           return new DListNoteEnum_<T>(_First);
        }   

}

    /// <summary>
    /// 节点数据的foreach迭代
    /// </summary>
    /// 创建时间：2020-05-07  最后一次修改时间： 2020-05-07
    /// <typeparam name="T"></typeparam>
    public class DListNoteEnum_<T> : IEnumerator
    {

        private DListNote_<T> _dn;
        private DListNote_<T> _dnCurr;
        private int _iIndex;


        public DListNoteEnum_(DListNote_<T> dn)
        {
            _dn = dn;
            _iIndex = -1;
        }


        /// <summary>
        /// IEnumerator最终调用的是这个函数访问
        /// </summary>
        public Object Current {  get{  return _dnCurr.Data; }  }


        public virtual bool MoveNext()
        {
            ++_iIndex; //指针首先向前移动一位

            if (_dnCurr == null)
            {
                _dnCurr = _dn;
            }
            else
            {
                _dnCurr = _dnCurr.Next;
            }
            return _dnCurr != null;
        }

        public virtual void Reset()
        {
            _dnCurr = null;

            _iIndex = -1;
        }
    };

Java

public class DList_<T extends Comparable<T>> implements Iterable<T>{
     /**
     * 排序方式
     */
    public enum Sortord_
    {
        s_min_max,   //从小到大
        s_max_min,   //从大到小
        s_null       //无排序顺序
    }


    protected DListNote_<T>  _first;          //第一个节点
    protected DListNote_<T>  _last;              //最后一个节点
    protected int  _count;                   //节点个数
    protected Sortord_ _sortord;                //排序顺序

    /**
     * 适用于 foreach 语句
     * @return
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Override
    public Iterator iterator() {
        return new Iterator() {
            private int m_cursor = -1;
            @Override
            public T next() {
                ++m_cursor;
                return indexOfNote(m_cursor).data;
            }
            @Override
            public boolean hasNext() {
                return m_cursor + 1 < _count;
            }
        };
    }

}

例子：