数组类的创建——DynamicArray.h

完成DynamicArray类的具体实现

DynamicArray设计要点——类模板 　　动态确定内部数组空间的大小 　　实现函数返回数组长度 　　拷贝构造和赋值操作

DynamicArray类的声明

template <typename T>
class DynamicArray : public Array<T>
{
protected:
    T m_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();
};

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

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

namespace DTLib
{
template <typename T>
class DynamicArray : public Array<T>
{
protected:
    T m_length;
public:
    DynamicArray(int length)
    {
        this->m_array = new T[length];

        if(this->m_array != NULL)
        {
            this->m_length = length;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "No memory to create DynamicArray object...");
        }
    }
    //拷贝构造和赋值操作
    DynamicArray(const DynamicArray<T>& obj )
    {
        this->m_array = new T[obj.m_length];

        if(this->m_array != NULL)
        {
            this->m_length = obj.m_length;

            for(int i=0; i<m_length; i++)
            {
                this->m_array[i] = obj.m_array[i];
            }
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "No memory to create DynamicArray object...");
        }
    }
    DynamicArray<T>& operator= (const DynamicArray<T>& obj)
    {
        if(this != &obj)
        {
            T* array = new T[obj.m_length];

            if(array != NULL)
            {
                for(int i=0; i<obj.m_length; 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(IndexOutOfBoundsException, "No memory to copy DynamicArray object...");
            }
        }

        return *this;
    }

    int length() const
    {
        return m_length;
    }
    void resize(int length) //动态重置数组的长度
    {
        if(m_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(IndexOutOfBoundsException, "No memory to resize DynamicArray object...");
            }
        }
    }

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

}

#endif // DYNAMICARRAY_H

测试：

#include <iostream>
#include "DynamicArray.h"

using namespace std;
using namespace DTLib;



int main()
{

    DynamicArray<int> sl(5);

    for(int i=0; i<sl.length(); i++)
    {
        sl[i] = i * i;
    }

    for(int i=0; i<sl.length(); i++)
    {
        cout << sl[i] << endl;
    }

    cout << endl;
    DynamicArray <int> s2(5);
    s2 = sl;
    for(int i=0; i<s2.length(); i++)
    {
        cout << s2[i] << endl;
    }

    cout << endl;

    s2.resize(10);
    for(int i=0; i<10; i++)
    {
        cout << s2[i] << endl;
    }
    return 0;

}

代码优化：

DynamicArray类中的函数实现存在重复的逻辑，如何进行代码优化？

重复代码逻辑的抽象——init 　　对象构造时的初始化操作——copy 　　在堆空间中申请新的内存，并执行拷贝操作——update 　　将指定的堆空间作为内部存储数组使用

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

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

namespace DTLib
{
template <typename T>
class DynamicArray : public Array<T>
{
protected:
    T 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(IndexOutOfBoundsException, "No memory to resize DynamicArray object...");
        }
    }

    void init(T* array, int length)
    {
        if(array != NULL)
        {
            this->m_array = array;
            this->m_length = length;
        }
        else
        {
            THROW_EXCEPTION(IndexOutOfBoundsException, "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)
        {
            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(m_length != length)
        {
            update(copy(this->m_array, m_length ,length),length);
        }
    }

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

}

#endif // DYNAMICARRAY_H