C++数据结构--数组类实现

实现的目标

 

1、需求分析

A:创建数组类代替原生数组的使用

1.数组类包含长度信息

2.数组类能够主动发现越界访问

2、Array(数组类)设计要点

1抽象类模板，存储空间的位置和大小由子类完成

2.重载数组操作符，判断访问下标是否合法

3.提供数组长度的抽象访问函数

4.提供数组对象间的复制操作

由以上的分析可以得出Array类的声明

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT界面开发-图像绘制，QT网络，QT数据库编程，QT项目实战，QSS，OpenCV，Quick模块，面试题等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓

template <typename T>
class Array:public Object//继承自Object顶层父类
{
	protected:
		T* m_array;
	public:// 虚函数的实现
		virtual bool set(int i,const T&e);
		virtual bool get(int i,T& e)const;
		virtual int length()const=0;
		//数组访问操作符
		T& operator[](int i);
		T operator[](int i)const;
};

3、StaticArray设计要点

A:类模板

1.封装原生数组

2.使用模板参数决定数组大小

3.实现函数返回数组长度

4.拷贝构造和复制操作

//StaticArray类的声明
template<typename T,int N>
class StaticArray:public Array<T>
{
	protected:
		T* m_space[N];
	public:
		StaticArray();
		//拷贝和赋值操作
		StaticArray(const StaticArray<T,N>& obj);
		StaticArray<T,N>& operator=(const StaticArray<T,N>& obj);
		
		int length()const;
};

4、DynamicArray设计要点

A.类模板

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

2.实现函数返回数组长度

3.拷贝构造和赋值操作

//DynamicArray类的声明
template<typename T>
class DynamicArray:public Array<T>
{
	protected:
		int 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();
};

5、完整的代码实现

Array
#ifndef ARRAY_H
#define ARRAY_H

#include "Object.h"
#include "Exception.h"
//原生数组类
namespace MyLib
{
    template <typename T>
    class Array: public Object
    {
    protected://protect继承 使得子类可以调用
        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;
        }
        virtual int length()const=0;//纯虚函数 子类实现
        //数组访问操作符
        T& operator[](int i)//数组重载操作符的实现
        {
            if((0<=i)&&(i<length()))
            {
                return m_array[i];
            }
            else
            {
                THROW_EXCEPTION(indexOutOfBoundsException,"Parameter i is invalid");//访问越界
            }
        }
        T operator[](int i)const
        {
            return(const_cast<Array<T>&>(*this))[i];//强制类型转换去除const属性
        }
    };
}

#endif // ARRAY_H


StaticArray
#ifndef STATICARRAY_H
#define STATICARRAY_H

#include "Array.h"
//设计要点
//1.封装原生数组
//2.使用模板参数决定数组大小
//3.实现函数返回数组长度
//4.拷贝构造和赋值操作
namespace MyLib
{
    template <typename T,int N>
    class StaticArray :public Array<T>
    {
    protected:
        T m_space[N];//原生数组
    public:
        StaticArray()
        {
            this->m_array=m_space;//父类的m_array指向子类的原生数组
        }

        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;
        }
    };
}

#endif // STATICARRAY_H


DynamicArray
#ifndef DYNAMICARRAY_H
#define DYNAMICARRAY_H

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

namespace MyLib
{
    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(NoEoughMemoryException,"...");
            }
        }
    public:
        DynamicArray(int length)
        {
            this->m_array=new T[length];//堆空间申请内存

            if(this->m_array!=NULL)
            {
                this->m_length=length;
            }
            else
            {
                THROW_EXCEPTION(NoEoughMemoryException,"No memory to ....");
            }
        }

        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(NoEoughMemoryException,"No memory to ....");
            }
        }

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

        int length() const
        {
            return m_length;
        }

        void resize(int length)
        {
            if(length!=m_length)
            {
                T* array=copy(this->m_array,m_length,length);
                update(array,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(NoEoughMemoryException,"No memory to...");
                    }
                    */
            }
        }

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

#endif // DYNAMICARRAY_H

本文福利，莬费领取Qt开发学习资料包、技术视频，内容包括（C++语言基础，Qt编程入门，QT信号与槽机制，QT界面开发-图像绘制，QT网络，QT数据库编程，QT项目实战，QSS，OpenCV，Quick模块，面试题等等）↓↓↓↓↓↓见下面↓↓文章底部点击莬费领取↓↓