顺序存储线性表的分析

1. SeqList类的效率分析

长度相同的两个SeqList，插入和删除操作的平均耗时不一定相同。

如SeqList<int> s1和SeqList<string> s2的插入操作，由于string的赋值涉及到字符串的拷贝，这就比int类型的拷贝耗时，因此s1和s2的平均耗时是不同的。

2、问题一：对象赋值的问题

StaticList<int* ,5> s1;
StaticList<int* ,5> s2;
for(int i=0 ;i<s1.capacity();i++)
{
    s1.insert(0, new int(i));//s1线性表中第0个位置插入堆空间中的一个地址，地址中存的是i
}                        //s1中有5个指针每个指针指向一个堆空间中的一个的整形数据

    s2=s1;//赋值可以成功 但是两个对象中的m_space[i]都指向同一个int*类型的堆空间

for(int i=0 ;i<s1.capacity();i++)
{
    delete s1[i];//即释放所指向所指向的堆空间
    delete s2[i];   
}

delete s1；

delete s2；

同一个堆空间被释放了两次，第二次释放了未定义的堆空间，一定发生问题，置于何时会变成bug就不知道了

问题二：对象拷贝问题

解决方案：对于容器类型的类，可以考虑禁用拷贝构造和赋值操作。将拷贝构造函数和赋值的的操作符声明为protected（可以被子类访问不能被外界访问的）

List.h和SeqList.h的改进

//List.h

#ifndef _LIST_H_
#define _LIST_H_

#include "Object.h"

namespace DTLib {

template <typename T>
class List : public Object
{
protected:
    //禁用拷贝构造函数和赋值操作符   即将拷贝构造函数和赋值操作法声明为保护的；
    List(const List&);
    List& operator=(const List&);
public:
    //由于以上手动添加了拷贝构造函数，编译将不再提供
    //默认的一些构造函数。这里需要手工加上无参构造函数
    List(){}
    virtual bool insert(const T& e) = 0;//往线性表尾部插入元素
    virtual bool insert(int index, const T& elem) = 0;
    virtual bool remove(int index) = 0;
    virtual bool get(int index, T& elem) const = 0;
    virtual int length() const = 0;
    virtual void clear() = 0;
};

}

#endif // _LIST_H_

//SeqList.h

#ifndef _SEQLIST_H_
#define _SEQLIST_H_

#include "list.h"
#include "Exception.h"

namespace DTLib {

template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array;    //顺序存储空间
    int m_length;  //当前线性表长度
public:
    //插入元素
    bool insert(int index, const T &elem)  //O(n)
    {
        bool ret = ((0 <= index)&&(index <= m_length));
        ret = ret && (m_length < capacity());

        if(ret){
            //将index及其之后的元素向后移动一个位置
            for(int pos=m_length-1; pos>=index; pos--){
                m_array[pos + 1] = m_array[pos];
            }
            //新元素插入在index位置
            m_array[index] = elem;
            m_length++;
        }

        return ret;
    }

    bool insert(const T& e) //O(n)  ==>往线性表尾部插入元素
    {
        return insert(m_length, e);
    }

    //删除元素
    bool remove(int index)     //O(n)
    {
        bool ret = ((0 <= index)&&(index < m_length));

        if(ret){
            for(int pos=index; pos<m_length-1; pos++){
                m_array[pos] = m_array[pos + 1];
            }

            m_length--;
        }

        return ret;
    }

    //设置元素
    bool set(int index, const T& elem)  //O(1)
    {
        bool ret = ((0 <= index)&&(index < m_length));

        if(ret){
            m_array[index] = elem;
        }

        return ret;
    }

    //获取元素
    bool get(int index, T &elem) const  //O(1)
    {
        bool ret = ((0 <= index)&&(index < m_length));

        if(ret){
           elem =  m_array[index];
        }

        return ret;
    }

    //当前长度
    int length()const    //O(1)
    {
        return m_length;
    }

    //清空线性表
    void clear()        //O(1)
    {
        m_length = 0;
    }

    //顺序存储线性表的数组访问方式
    T& operator[](int index)  //O(1)
    {
        if((0<=index) && (index<m_length)){
            return m_array[index];
        }else{
            THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter index is invalid ...");
        }
    }

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

    //顺序存储空间的容量
    virtual int capacity()const = 0;
};

}

#endif // _SEQLIST_H_