第十九课 数组类的创建（上）

基于顺序存储结构的线性表可能被当成数组来误用，这一节我们要设计数组类来代替原生数组。

课程目标：

Array是一个抽象类，这个类存在的意义就是用来被继承。

需求分析：

 

原生数组是不提供复制操作的，我们自己的数组要提供复制操作。

length（）成员函数设置为纯虚函数，说明这个类是一个纯虚类，用于被继承，具体实现在子类中完成。

 在工程中添加Array.h文件：

#ifndef ARRAY_H
#define ARRAY_H

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

namespace DTLib
{

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

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

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

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

    virtual int length() const = 0;
};

}

#endif // ARRAY_H

StaticArray设计：

添加StaticArray.h文件，如下：

#ifndef STATICARRAY_H
#define STATICARRAY_H

#include "Array.h"

namespace DTLib
{

template <typename T, int N>
class StaticArray : public Array<T>
{
protected:
    T m_space[N];
public:
    StaticArray()   //O(1)
    {
        this->m_array = m_space;   //将定义的原生数组挂接到指针上去
    }

    StaticArray(const StaticArray<T, N>& obj)  //O(n)
    {
        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)  //O(n)
    {
        if( this != &obj )
        {
            for(int i = 0; i < N; i++)
            {
                m_space[i] = obj.m_space[i];
            }
        }

        return *this;
    }

    int length() const   // O(1)
    {
        return N;
    }
};

}

#endif // STATICARRAY_H

测试程序如下：

#include <iostream>
#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;
    }

    return 0;
}

运行结果如下：

第16、21行可以使用数组下标访问了，打印结果也是正确的。

第二个测试程序：

#include <iostream>
#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;
    }

    return 0;
}

结果如下：

可以看到第26行数组之间的赋值完全是合法的。

修改测试程序：

#include <iostream>
#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;
    }

    s2[6] = 100;

    return 0;
}

结果如下：

可以看到33行的越界赋值引发了异常，这样做的好处是在有bug的地方立即抛出异常，而不是等到程序运行了很长时间才出现bug，那时候定位bug是很困难的。

 抛出异常这种方式不会引起bug的传播。有问题的地方就立即反应出来。

原生数组是做不到这一点的。