需求分析

-建立陣列類代替原生陣列的使用

·陣列類包含長度資訊

·陣列類能夠主動發現越界訪問

Array設計要點

-抽象類模板，儲存空間的位置和大小由子類完成

-過載陣列操作符，判斷訪問下標是否合法

-提供陣列長度的抽象訪問函式

-提供陣列物件間的複製操作

Array類的宣告

template <typename T>
class Array : public Object
{
protected:
    T* m_array;
public:
    virtual bool set(int i,const T& e)
    {
        bool ret = ((0 <= i) && (i < length()));

        if(ret)
        {
            m_array[i] = e;
        }

        return ret;
    }

    virtual bool get(int i,T& e) const
    {
        bool ret = ((0 <= i) && (i < length()));

        if(ret)
        {
            e = m_array[i];
        }

        return ret;
    }

    T& operator[] (int i)
    {
        if((0 <= i) && (i < length()))
        {
            return m_array[i];
        }
        else
        {
            //丟擲異常
        }
    }

    T operator[] (int i) const
    {
        return (const_cast<Array<T>&>(*this)[i]);
    }

    virtual int length() const = 0;




};
 

StaticArray設計要點

-類模板

·封裝原生陣列

·使用模板引數決定陣列大小

·實現函式返回陣列長度

·拷貝構造和賦值操作

StaticArray類的宣告

template <typename T, int N>
class StaticArray : public Array<T>
{
protected:
    T m_space[N];
public:
    StaticArray()
    {
        this->m_array = m_space;
    }

    StaticArray(const StaticArray<T,N>& obj)
    {
        this->m_array = m_space;

        for(int i = 0; i<N ;i++)
        {
            m_space[i] = obj.m_space[i];
        }
    }

    StaticArray<T,N>& operator= (const StaticArray<T,N>& obj)
    {
        if(this != &obj)
        {
            for(int i =0;i<N ;i++)
            {
                m_space[i] = obj.m_space[i];
            }
        }

        return *this;
    }

    int length() const
    {
        return N;
    }
};
 

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
        {
            //丟擲異常
        }
    }

    void init(T* array,int length)
    {
        if(array != NULL)
        {
            this->m_array = array;
            this->m_length = length;
        }
        else
        {
            //丟擲異常
        }
    }

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),obj.m_length);
    }

    DynamicArray<T>& operator= (const DynamicArray<T>& obj)
    {
        if(this != &obj)
        {
            update(copy(obj.m_array,obj.m_length,obj.m_length),obj.m_length);

        }

        return *this;
    }

    void resize(int length)
    {
        if(length != m_length)
        {

             update(copy(this->m_array,m_length,length),length);

        }
    }

    int length() const
    {
        return m_length;
    }


    ~DynamicArray()
    {

    }
};
 

總結：

-StaticArray通過封裝原生陣列的方式實現陣列類

-DynamicArray動態申請堆空間，是的陣列長度動態可變

-陣列物件能夠代替原生陣列，並且使用上更安全

-程式碼優化是專案開發過程中不可或缺的環節