数组类的创建（上）

线性表会被误用  线性表会被当做数组用   ---》》数组类

1、 数组类继承图

对象模拟数组的行为

原生数组

• 不会发现是否越界
• 不能直接复制
• 不能提供其长度信息

 2、数组类需求分析

• 创建数组类替代C++中的原生数组的使用
• 数组类包含长度信息
• 数组类能够发现数组越界访问

3、Array的设计要点

• 抽象类模板，存储空间的位置和大小由子类完成
• 重载数组操作符，判断访问下标是否合法
• 提供数组长度的抽象访问函数
• 提供数组对象间的复制

template <typename T>  
class Array : public 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* array() const;
  
    T& operator [] (int i)；
    T operator [] (int i) const ；
}；

note：

• T* m_array  指向一段内存空间 该空间保存数组中元素的位置（有可能堆空间也有可能是栈空间）
• int length() const  =0 获取数组长度 设置为纯虚函数则有
  • 当前类为抽象父类，用于被继承
  • 实现在子类中完成

 //Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

#include "Object.h"
#include "Exception.h"

namespace DataStructureLib
{
template <typename T>
class Array : public Object
{
protected:
    T* m_array;
public:
    virtual bool set(int i, const T& e)  //O(1)
    {
        bool ret = ( 0<=i ) && (i < length());
        if (ret){
            m_array[i] = e;
        }

        return ret;
    }

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

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

        return ret;
    }

    virtual int length() const = 0;

    //数组访问操作符
    T& operator[](int i)  //O(1)
    {
        if (( 0<=i ) && (i < length())){
            return m_array[i];
        }else{
            THROW_EXCEPTION(IndexOutOfBoundsException,"Parameter i is invalid ....");
        }
    }

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

}

#endif // _ARRAY_H_

4、StaticArray设计要点

• 类模板
• 封装原生数组类
• 使用模板参数决定数组大小（原生数组的表现形式即 StaticArray 里面的一个成员）
• 实现函数返回数组长度
• 拷贝构造和赋值的操作（原生数组不能直接复制）

 

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

 

Staticarray.h

 

 

#ifndef STATICARRAY_H
#define STATICARRAY_H
#include "array.h"

namespace  DataStructureLib
{
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++)
        {
            this->m_array[i]=obj.m_array[i];
        }
    }

    StaticArray<T,N> operator =(const StaticArray<T,N>& obj)
    {

        if(this!=&obj)
        {
          for(int i=0;i<N;i++)
         {
             this->m_array[i]=obj.m_array[i];
         }
        }
    return *this;
    }

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

 main.cpp

#include <iostream>
#include "Exception.h"
#include "staticarray.h"

using namespace std;
using namespace DTLib;

int main()
{
     StaticArray<int,5> s1;

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


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

     StaticArray<int ,5> s2;

     s2=s1;

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

    int s3[5];
    s3[6]=100;//正常数组越界，不会报错不会异常难以调试
    try
     {
         s2[6]=0;//越界报异常
     }
     catch(Exception& e)  //Exception是一个抽象类  catch(Exception e)会出错 ：抽象类不能实例化  所以需要用引用或者指针
     {
         cout<<e.location()<<endl;
         cout<<e.message()<<endl;
     }
     return 0;
}

得到