数据结构--数组类之DynamicArray类

上一篇我们实现了Array的子类：StaticArray类，今天我们实现Array的另一个子类：DynamicArray类。

DynamicArray类的设计要点：

用类模板实现。

继承自Array类。

动态确定内部数组空间的大小。

实现返回数组长度的函数。

实现拷贝构造和赋值操作功能。

对重复逻辑进行优化。

下面是DynamicArray类的声明：

    template <typename T>
    class DynamicArray : public Array<T>
    {
    protected:
        int m_length;

        T* copy(T* array, int len, int newlen);//新申请一个数组，并将原先数组内容拷贝至新空间。
        void update(T* array, int length);//更新数组指向和大小
        void init(T* array,int length);//对数组初始化，赋予空间和长度
       
    public:
        
        DynamicArray(int length);
        DynamicArray(const DynamicArray<T>& obj);
        DynamicArray<T>& operator =(const DynamicArray<T>& obj);
        int length() const;
        void resize(int length);

        ~DynamicArray();
       
    };

将代码出现的重复逻辑抽象成类的保护成员，供公有成员调用。

其中：

init作用：对象构造时的初始化操作

copy作用：在堆空间申请新的内存，并执行拷贝构造操作

update作用：将指定的堆空间作为内部存储数组使用，实现上保证了异常安全

将重复代码进行抽象后使得程序结构清晰，每个函数的功能十分明确。

下面是DynamicArray的完整实现。

    template <typename T>
    class DynamicArray : public Array<T>
    {
    protected:
        int m_length;

        T* copy(T* array, int len, int newlen)//新申请一个数组，进行数组拷贝
        {
            T* ret = new T[newlen];
            if(ret != NULL)
            {
                int size = (len < newlen) ? len : newlen;
                for(int i = 0; i < size; i++)
                {
                    ret[i] = array[i];
                }
            }
            return ret;
        }

        void update(T* array, int length)
        {
            if(array != NULL)
            {
                T* temp = this->m_array;

                this->m_array = array;
                this->m_length = length;

                delete [] temp;
            }
            else
            {
                 THROW_EXCEPTION(NoEnoughMemoryException,"No memory to update  DynamicArray object...");
             }
        }

        void init(T* array,int length)
        {
            if(array != NULL)
            {
                this->m_array = array;
                this->m_length = length;

            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException,"No memory to create DynamicArray object...");
            }
        }
    public:
        DynamicArray(int length)
        {
            init(new T[length],length);
        }

        DynamicArray(const DynamicArray<T>& obj)
        {
            init(copy(obj.m_array,obj.m_length,obj.m_length),obj.m_length);
        }

        DynamicArray<T>& operator =(const DynamicArray<T>& obj)
        {
            if(this != &obj)
            {
                //将obj的内容复制出来
                update(copy(obj.m_array,obj.m_length,obj.m_length),obj.m_length);
           }

            return *this;
        }

        int length() const
        {
            return m_length;
        }

        void resize(int length)
        {
            if(length != m_length)
            {
                //将this的内容复制出来
                update(copy(this->m_array,m_length,length),length);
            }
        }

        ~DynamicArray()
        {
            delete [] this->m_array;
        }

    };

DynamicArray数组类优势在于可以动态指定数组长度使用resize函数，数组对象能够代替原生数组，使用上也更安全。