数组类

 数组类：实现越界检测，数组对相间的赋值，数组长度值访问

array.h

/*
 *    Array: 数组类接口
 *    成员变量：
 *                m_array    指向子类的实体数组地址
 *  成员函数：
 *                set        设置数组某一项值
 *                get           获取数组某一项值
 *                length     纯虚函数
 *                operator[]
*/

#ifndef ARRAY_H
#define ARRAY_H

#include "TopClass.h"
#include "Exception.h"


namespace DSL
{
    template <typename T>
    class Array: public TopClass
    {
        protected:
                T* m_array;
        public:
                virtual bool set(int pos, const T& obj)
                {
                    if((pos >= 0) && ( pos < length()))
                    {
                        m_array[pos] = obj;    
                        return 1;
                    }
                    else
                    {
                        return false;
                    }
                }

                virtual bool get(int pos, T& obj) const
                {
                    if((pos >= 0) && ( pos < length()))
                    {
                        obj = m_array[pos];    
                        return 1;
                    }
                    else
                    {
                        return false;
                    }
                }

                T& operator[] (int pos)
                {
                    if((pos >= 0) && (pos < length()))
                    {
                        return m_array[pos];
                    }
                    else
                    {
                        THROW_EXCEPTION(IdexOutOfBoundException, "error: index is out of bound!");
                    }
                }

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

                virtual int length() const = 0 ;
    };

}

#endif

StaticArray.h

/*
*    StaticArray: 静态数组
*    成员变量：
*                m_space  定义数组实体
*            
*    成员函数：
*                StaticArray 构造函数
*                StaticArray 拷贝构造函数
*                operator=   赋值重载函数
*                length()    长度函数
*/
#ifndef STATICARRAY_H
#define STATICARRAY_H

#include"Array.h"

namespace DSL
{
    template <typename T, int N>
    class StaticArray : public Array<T>
    {
        protected:
                T m_space[N];    // 使用C++的原生数组
        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];    
                        }
                    }
                    else
                    {
                        return *this;
                    }
                }

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

DynamicArray.h

/*
*    DynamicArray：动态数组模板
*    成员变量：
*                m_length   动态数组的实时长度
*    成员函数：
*                DynamicArray()   申请堆空间,初始化成员变量    
*                DynamicArray()   申请堆空间,初始化堆空间,初始化成员变量  
*                operator=()      申请堆空间,初始化堆空间,初始化成员变量,释放原始堆空间  
*                length()         返回动态数组长度
*                resize()         申请堆空间,初始化堆空间,初始化成员变量,释放原始堆空间
*                ~DynamicArray()  释放堆空间
*/

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

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

namespace DSL
{
    template <typename T>
    class DynamicArray: public Array<T>
    {
        protected:
                int m_length;
        public:
                DynamicArray(int length)
                {
                    this->m_array = new T[length];
                    if(this->m_array != NULL)
                    {
                        this->m_length =  length;
                    }
                    else
                    {
                        THROW_EXCEPTION(NotEnoughMemoryException,"error: no enough memory to init array");
                    }
                }

                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 < obj.m_length; i++)
                        {
                            this->m_array[i] = obj.m_array[i];
                        }
                    }
                    else
                    {
                        THROW_EXCEPTION(NotEnoughMemoryException, "error: no enough memory to copy array");
                    }
                }

                DynamicArray<T>& operator=(DynamicArray<T>& obj)
                {
                    if(&obj != this)
                    {
                        T* array = new T[obj.m_length];
                        if(array != NULL)
                        {
                            for(int i = 0; i++; i<0)
                            {
                                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(NotEnoughMemoryException, "error: no enough memory to assignment array");
                        }
                    }
                    return *this;
                }

                int length() const
                {
                    return m_length;
                }

                void resize(int new_length)
                {
                    if(new_length != m_length)
                    {
                        T* array = new T[m_length];
                        if(array != NULL)
                        {
                            int size =  (m_length > new_length) ? new_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 = new_length;
                            delete[] temp;
                        }
                        else
                        {
                            THROW_EXCEPTION(NotEnoughMemoryException, "error: no enough memory to resize array");
                        }
                        
                    }

                }

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

}

#endif

DynamicArray.h

/*
*    DynamicArray：动态数组模板
*    成员变量：
*                m_length   动态数组的实时长度
*    成员函数：
*                init()      初始化成员变量,抛出异常
*                copy()      申请堆空间，初始化堆空间
*                update()    初始化成员变量，释放堆空间
*
*                DynamicArray()   申请堆空间,初始化成员变量    
*                DynamicArray()   申请堆空间,初始化堆空间,初始化成员变量  
*                operator=()      申请堆空间,初始化堆空间,初始化成员变量,释放原始堆空间  
*                length()         返回动态数组长度
*                resize()         申请堆空间,初始化堆空间,初始化成员变量,释放原始堆空间
*                ~DynamicArray()  释放堆空间
*/

#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

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

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

                void init(T* array, int length)
                {
                    if(array != NULL)
                    {
                        this->m_array = array;
                        this->m_length = length;
                    }
                    else
                    {
                        THROW_EXCEPTION(NotEnoughMemoryException, "error: no enough memory ");
                    }
                }
                
                T* copy(T* array, int length, int new_length)
                {
                    T* ret = new T[new_length];
                    if(ret != NULL)
                    {
                        int size = (new_length > length ? length : new_length);
                        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;
                    }
                }
                
        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=(DynamicArray<T>& obj)
                {
                    if(&obj != this)
                    {
                        init(copy(obj.m_array,obj.m_length,obj.m_length), obj.m_length);
                    }
                    return *this;
                }

                int length() const
                {
                    return m_length;
                }

                void resize(int new_length)
                {
                    if(new_length != m_length)
                    {
                        update(copy(this->m_array, m_length, new_length), new_length);    
                    }
                }

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

}

#endif