顺序存储结构的抽象实现

Posted 2021-10-12 学习只为旅行

#ifndef SEQLIST_H
#define SEQLIST_H

#include "List.h"
#include "Exception.h"

namespace DragonLib
{

template <typename T>
class SeqList : public List<T>
{
protected:
    T* m_array;
    int m_length;
public:
    bool insert(int i,const T& e)
    {
        bool ret = ((0<=i) && (i<=m_length));
        ret = ret && (m_length < capacity());

        if(ret)
        {
            for(int p=m_length-1;p>=i;p--)
            {
                m_array[p+1]=m_array[p];
            }
            m_array[i]=e;
            m_length++;
        }
        return ret;

    }

    bool remove(int i)
    {
        bool ret = ((0<=i) && (i<m_length));

        if(ret)
        {
            for(int p=i;p<m_length;p++)
            {
                m_array[p] = m_array[p+1];
            }
            m_length--;
        }
        return ret;
    }

    bool set(int i,const T& e)
    {
        bool ret = ((0<=i) && (i<m_length));
        if(ret)
        {
            m_array[i]=e;
        }
        return ret;
    }

    bool get(int i,T& e) const
    {
        bool ret = ((0<=i) && (i<m_length));

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

    int length() const
    {
        return m_length;
    }

    void clear()
    {
        m_length=0;
    }

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

    //给const对象调用
    T operator[] (int i) const
    {
        //其实完全可以赋值上面的代码
        //但是可以代码复用，相当于就是调用上面的非const属性的函数
        //首先这个函数被调用，那么对象肯定就是const属性的，先去除const属性
        return (const_cast<SeqList<T>&>(*this))[i];
    }

    //顺序u存储空间的容量
    virtual int capacity() const = 0;//交给子类实现
};
}
#endif // SEQLIST_H

小结