数据结构中的数组——静态数组类的创建

1，顺序存储线性表两个问题：

       1，当做数组误用；

       2，效率有隐患；

      

2，本文解决第一个功能上的问题，创建一个数组类代替顺序存储结构中的数组访问操作符；

3，本文目标：

 

       1，完成 Array 类的具体实现；

       2，完成 StaticArray 类的具体实现，替代原生数组；

      

4，需求分析：

       1，创建数组类代替原生数组的使用；

              1，数组类包含长度信息；

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

             

5，Array 设计要点：

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

       2，重载数组操作符，判断访问下标是否合法（满足上面第二点，且满足原生数组访问操作）；

       3，提供数组长度的抽象访问函数（满足上面第一点）；

       4，提供数组对象间的复制操作（附加的功能）；

      

6，Array 类的声明；

      

      

7，Array 数组抽象类实现：

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

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

    //数组访问操作符
    T& operator[] (int i)    // O(1)
    {
        bool ret = ((0 <= i) && (i < length()));

        if( ret )
        {
            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];
　　 }

    /* 直接返回原生数组的首地址，为了能够通过这个函数返回数组元素，然后对数组元素排序 */
    T* array() const
    {
        return m_array;
　　 }

    virtual int length() const = 0;
};

}

#endif // ARRAY_H

8，StaticArray 设计要点：

       1，类模板（创建原生数组替代品，可以直接指定数据元素类型，所以必须是类模板）：

              1，封装原生数组；

                     1，父类中没有完成的具体元素应该保存在什么地方；

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

                     1，用成员函数来表现；

              3，实现函数返回数组长度；

              4，拷贝构造和赋值操作；

                     1，数组对象可以相互赋值的，这是附加的语义；

                    

9，StaticArray 类的声明；

      

      

10，StaticArray 静态数组类的实现：

#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

11，StaticArray 的测试代码：

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

using namespace std;
using namespace DTLib;

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

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

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

    StaticArray<int, 5> l1;
　　 l1 = l;

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

　　 l[5] = 100;

    return 0;
}