[C++11笔记001]修改通用库中的XDynamicArray，使它可以支持C++11的初始化列表和for循环

今天，有空翻了一下<C++Primer plus(第六版)>，看到里面有介绍新的for循环和初始化列表，但是我实现的动态数组XDynamicArray不支持这些新特性，没办法，只好进行改造了。
首先是for循环，如下面的样式

for(auto e:stList)
{
    cout<<e<<endl;
}

是于就各种google，和查找C++11的array的源代码，总结：就是提供一个标准的iterator和begin,end这两个方法，就可以了。
是于定义了一个iterator

     // 一个数组的Array的Iterator类
     /*
        这里提供XArrayIterator这个类，目的是使得这里支持C++11的for循环
     */
    template< class Array>
     class XArrayIterator
    {
     public:
        typedef typename Array::ElementType & reference;
        typedef typename Array::ElementType * pointer;


        XArrayIterator()
            :m_Index(ARRAY_INVALID_INDEX), m_Array(nullptr)
        {}

        XArrayIterator(Array * paramArray, XInt paramIndex)
            :m_Index(paramIndex), m_Array(paramArray)
        {}

        XArrayIterator(Array & paramArray, XInt paramIndex)
            :m_Index(paramIndex), m_Array(&paramArray)
        {}

        XArrayIterator( const XArrayIterator<Array> & paramR)
            :m_Index(paramR.m_Index), m_Array(paramR.m_Array)
        {}

        XArrayIterator &  operator = ( const XArrayIterator<Array> & paramR)
        {
             if ( this != &paramR)
            {
                m_Index = paramR.m_Index;
                m_Array = paramR.m_Array;
            }
             return * this;
        }

        XArrayIterator &  operator = (Array * paramArray)
        {
            m_Array = paramArray;
             if (isNotNULL(m_Array))
            {
                m_Array = m_Array->getFirstIndex();
            }
             else
            {
                m_Index = ARRAY_INVALID_INDEX;
            }
             return * this;
        }

         bool  operator == ( const XArrayIterator<Array> & paramR)
        {
             return m_Index == paramR.m_Index && m_Array == paramR.m_Array;
        }

         bool  operator != ( const XArrayIterator<Array> & paramR)
        {
             return m_Index != paramR.m_Index || m_Array != paramR.m_Array;
        }
        
        reference  operator*()
        {    
             return (*m_Array)[m_Index];
        }
        
         const reference  operator*()  const 
        {    
             return (*m_Array)[m_Index];
        }

        pointer  operator->()
        {    
             return &(*m_Array[m_Index]);
        }

         const pointer  operator->()  const
        {    
             return &(*m_Array[m_Index]);
        }

        XArrayIterator &  operator ++()
        {
             if (m_Index != ARRAY_INVALID_INDEX && isNotNULL(m_Array))
            {
                m_Index++;
                 if (m_Index >= m_Array->getLength()) m_Index = ARRAY_INVALID_INDEX;
            }
             return * this;
        }


        XArrayIterator  operator ++( int)
        {
            XArrayIterator stRet = * this;
             if (m_Index != ARRAY_INVALID_INDEX && isNotNULL(m_Array))
            {
                m_Index++;
                 if (m_Index >= m_Array->getLength()) m_Index = ARRAY_INVALID_INDEX;
            }
             return stRet;
        }

        XArrayIterator &  operator --()
        {
             if (m_Index != ARRAY_INVALID_INDEX && isNotNULL(m_Array))
            {
                m_Index--;
                 if (m_Index < 0) m_Index = ARRAY_INVALID_INDEX;
            }
             return * this;
        }


        XArrayIterator  operator --( int)
        {
            XArrayIterator stRet = * this;
             if (m_Index != ARRAY_INVALID_INDEX && isNotNULL(m_Array))
            {
                m_Index--;
                 if (m_Index < 0) m_Index = ARRAY_INVALID_INDEX;
            }
             return stRet;
        }

        XArrayIterator &  operator +=(XInt paramOffset)
        {
             if (m_Index != ARRAY_INVALID_INDEX && isNotNULL(m_Array))
            {
                m_Index += paramOffset;
                 if (!(m_Index >= 0 && m_Index < m_Array->getLength()))
                {
                    m_Index = ARRAY_INVALID_INDEX;
                }
            }
             return * this;
        }

        XArrayIterator  operator + (XInt paramOffset)  const
        {
            XArrayIterator stRet = * this;
            stRet += paramOffset;
             return stRet;
        }

        XArrayIterator &  operator -=(XInt paramOffset)
        {
             return  operator += (-paramOffset);
        }

        XArrayIterator  operator - (XInt paramOffset)  const
        {
            XArrayIterator stRet = * this;
            stRet -= paramOffset;
             return stRet;
        }
     private:
        XInt m_Index;
        Array * m_Array;
    };

然后在XDynamicArray两个方法

typedef XArrayIterator<XDynamicArray<T> > iterator
         /* 这里定义begin和end主要有两个目的
            目的1：使它可以像标准STD容器那样遍历
            目的2：使它可以支持C++11的for循环
            例子：
            XDynamicArray<int> st;
            for(auto x:st)
            {
                cout<<x<<endl;
            }
         */
        iterator begin() 
        {
            iterator stRet( this,  this->getFirstIndex());
             return stRet;
        }

        iterator end() 
        {
            iterator stRet( this, ARRAY_INVALID_INDEX);
             return stRet;
        }

这样就可以了，测试通过。你们也可以试试。
C++11的另一个特性，就是新初始化列表，如下面例子

vector st {1,2,3,4,5};

看起来有点意思，于是又google一下，翻阅了各位大神的贴子，最终找到，然后我就实现了。这部分需要使用C++11的initializer_list模板类，具体使用代码如下。

         // 这个构造函数的定义，是为了实现C++11的初始化列表，如下例子
         /*
            XDynamicArray<int> st {1,2,3,4,5};
            或 XDynamicArray<int> st = {1,2,3,4,5};
         */
        XDynamicArray(std::initializer_list<T> paramList)
            : m_Length(0),
             m_Capacity(0),
             m_Data(NULL)
        {
             this->ensureCapacity((XInt)paramList.size());
             for (auto e : paramList)
            {
                Append(e);
            }
        }

使用initializer_list需要头文件：#include <initializer_list>
上述代码，已经放到我的开放库中了，大家可以自行下载。 我的开放代码