数据结构中的数组——动态数组的创建

1，StaticArray 确实可以代替原生数组使用，但是在创建 StaticArray 对象时，数组大小必须明确指定，能不能创建一个对象在使用过程中，对象的大小可以动态指定，且功能超越 StaticArray；

2，课程目标：

 

       1，本节课完成 DynamicArray 类的创建,；

       2，Dynamic 指的是数组的大小可以动态指定；

      

3，DynamicArray 设计要点：

       1，类模板：

              1，动态确定内部数组空间的大小；

              2，实现函数返回数组长度；

              3，拷贝构造和赋值操作；

              4，动态重置数组大小；

4，DynamicArray 类的声明：    

      

5，DynamicArray 动态数组的实现：

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

#include "Array.h"
#include "Exception.h"

namespace DTLib
{

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

    T* copy(T* array, int length, int newlength)  // O(min(len, newlen)) ==> O(n);
    {
        T* ret = new T[newlength];
        if( ret != NULL )
        {
            int size = ((length < newlength) ? length : newlength);
            for(int i=0; i<size; i++)
            {
                ret[i] = array[i];
            }
        }
        return ret;
　　 }

    void update(T* array, int length)  // O(1)
    {
        if( array != NULL )
        {
            T* temp = this->m_array;
            this->m_array = array;
            this->m_length = length;
            delete[] temp;
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory to update DynamicArray object ...");
        }
　　 }

    void init(T* array, int length)  // O(1)
    {
        if( array != NULL )
        {
            this->m_array = array;
            this->m_length = length;
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory to init DynamicArray object ...");
        }
　　 }

public:
    DynamicArray(int length = 0)    // O(1)    动态数组如果不指定大小，则默认的数组大小为零；
    {
        init(new T[length], length);
/*
        this->m_array = new T[length];
        if(this->m_array != NULL)
        {
            this->m_length = length;
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create DynamicArray object ...");
        }
*/
　　 }

    DynamicArray(const DynamicArray<T>& obj)        // O(n)
    {
        init(copy(obj.m_array, obj.m_length, obj.m_length), obj.m_length);
/*
        this->m_array = new T[obj.m_length];
        if(this->m_array != NULL)
        {
            this->m_length = obj.m_length;
            for(int i=0; i<obj.m_length; i++)
            {
                this->m_array[i] = obj.m_array[i];
            }
        }
        else
        {
            THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create DynamicArray object ...");
        }
*/
　　 }

    DynamicArray<T>& operator= (const DynamicArray<T>& obj)   // O(n)
    {
        if( this != &obj )
        {
            update(copy(obj.m_array, obj.m_length, obj.m_length), obj.m_length);
/*
            T* array = new T[obj.m_length];   // 改写到这里
            if( array != NULL )
            {
                for(int i=0; i<obj.m_length; i++)
                {
                    //this->m_array[i] = obj.m_array[i];
                    array[i] = obj.m_array[i];
                }
                T* temp = this->m_array;
                this->m_array = array;
                this->m_length = obj.m_length;
                delete[] temp;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to create DynamicArray object ...");
            }
*/
        }

        return *this;
　　 }

    void resize( int length )   // O(n)
    {
        if( length != m_length)
        {
            update(copy(this->m_array, this->m_length, length), length);
/*
            T* array = new T[length];
            if( array != NULL )
            {
                int size = (length < m_length) ? length : m_length;
                for(int i=0; i<size; i++)
                {
                    array[i] = this->m_array[i];
                }
                T* temp = this->m_array;
                this->m_array = array;
                this->m_length = length;
                delete[] temp;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException, "No memory to resize object ...");
            }
*/
        }
　　 }

    int length() const   // O(1)
    {
        return m_length;
　　 }

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

}

#endif // DYNAMICARRAY_H

6，DynamicArray 类中的函数实现存在重复的逻辑，如何进行代码优化（优化见本文 5 中的实现）？

　　 1，init，对象构造时的初始化操作；

　　 2，copy，在堆空间中申请新的内存，并执行拷贝操作；

　　 3，update，将指定的堆空间作为内部存储数组使用；

7，实现代码优化中：

       1，重复代码抽象为保护成员函数；

       2，提供功能用于实现公有函数功能；

      

8，小结：

       1，StaticArray 通过封装原生数组的方式实现数组类；

       2，DynamicArray 动态申请堆空间，使得数组长度动态可变；

       3，数组对象能够代替原生数组，并且使用上更安全；

       4，代码优化是项目开发过程中不可或缺的环节：

              1，每一个函数足够小；

              2，每一个函数只做一件事；