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

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

2024-07-15 18:39:26   220人阅读

今天，有空翻了一下<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>
上述代码，已经放到我的开放库中了，大家可以自行下载。我的开放代码


联系
我们