【C++】使用C++手动封装一个顺序表，包含成员数组一个，成员变量N个

 1、使用C++手动封装一个顺序表，包含成员数组一个，成员变量N个

        错误记录：在add添加数据函数中，使用full函数判满操作后，调用完expend二倍扩容函数后，没有去处return 0，导致虽然成功扩容，但是数据少了一位。

#include <iostream>

using namespace std;

using datatype = int;           //类型重定义
#define MAX 5

struct SeqList
{
    private:
        datatype *data;         //顺序表的数组
        int size = 0;           //数组的大小
        int len = 0;            //顺序表的实际长度

    public:
        //初始化函数
        void init(int s);

        //判空函数
        bool empty();

        //判满函数
        bool full();

        //添加数据函数
        bool add(datatype e);

        //求当前顺序表的实际长度
        int length();

        //遍历表中数据
        void show();

        //任意位置插入函数
        bool insert_pos(int pos,datatype e);

        //任意位置删除函数
        bool delete_pos(int pos);

        //访问容器中的任意一个元素
        datatype &at(int index);

        //二倍扩容
        void expend();
};

void SeqList::init(int s)
{
    size = s;                       //当前数组的最大容量
    data = new datatype[size];      //在堆区申请一个顺序表容器
}

bool SeqList::empty()
{
    return len == 0;                //如果len等于0，返回真（1），表示表为空
}

bool SeqList::full()
{
    return len == size;             //如果len等于size，返回真（1），表示表已满
}

void SeqList::show()
{
    cout<<"表中的数据为:";
    for(int i = 0; i < len; i++)
    {
        cout<<data[i]<<",";
    }
    cout<<endl;
}

int SeqList::length()
{
    return len;
}

bool SeqList::insert_pos(int pos,datatype e)
{
    if(pos < 0 || pos > len || full())
    {
        cout<<"位置输入有误，或者表已满"<<endl;
        return 0;
    }

    //循环将元素后移
    for(int i = len-1; i >= pos-1; i--)
    {
        data[i+1] = data[i];
    }
    data[pos-1] = e;     //赋值到指定位置上
    len++;              //顺序表长度加1
    cout<<"按位置插入数据成功"<<endl;

    return 1;
}

bool SeqList::delete_pos(int pos)
{
    if(pos < 0 || pos > len || empty())
    {
        cout<<"位置输入有误，或者表为空"<<endl;
        return false;
    }

    //根据位置将后续元素向前覆盖
    for(int i = pos-1; i < len-1; i++)
    {
        data[i] = data[i+1];
    }
    len--;                  //表长减1

    cout<<"按位置删除数据成功"<<endl;
    return true;
}

datatype &SeqList::at(int index)
{
    if(index < 0 || index >= len)
    {
        cout<<"位置输入有误"<<endl;
    }
    return data[index-1];             //返回想要找的元素
}

void SeqList::expend()
{
    if(len == size)
    {
        //定义一个新的容器，大小为原来的2倍
        datatype *temp = new datatype[size * 2];
        //复制旧元素到新的内存空间中
        for(int i = 0; i < len; i++)
        {
            temp[i] = data[i];
        }
        delete []data;  //释放旧内存空间
        data = temp;    //将新容器赋值给旧的容器
        size *= 2;      //大小为原来的两倍
        cout<<"二倍扩容成功"<<endl;
    }
}


bool SeqList::add(datatype e)
{
    //如果满了就执行二倍扩容
    if(full())
    {
        expend();
    }
    data[len++] = e;            //将e的值赋值给data[len]，len从0开始，赋值完后len自增1
    cout<<"插入数据成功"<<endl;
    return 1;
}


int main()
{
    SeqList list;           //定义一个顺序表

    list.init(MAX);          //对顺序表进行初始化，并分配内存
    list.add(20);            //插入20
    list.add(520);            //插入520
    list.add(1314);            //插入1314
    list.add(30);            //插入30
    list.add(40);            //插入40

    list.show();             //输出数据

    /*************************************************************/
    //1、求数组当前长度
    int lenS = list.length();
    cout<<"数组长度为:"<<lenS<<endl;

    list.add(666);            //插入666，这里是为了验证二倍扩容是否成功

    //2、再次求数组当前长度
    lenS = list.length();
    cout<<"数组长度为:"<<lenS<<endl;

    list.show();             //输出数据

    /*************************************************************/
    list.insert_pos(2,666);      //在2号位置插入666

    list.show();             //输出数据

    list.delete_pos(2);         //删除2号位置数据

    list.show();             //输出数据

    datatype &num = list.at(3);

    cout<<"num = "<<num<<endl;


    return 0;
}

输出结果如下：

2、思维导图