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

实现顺序表的判空，判满，添加数据，求实际长度，任意位置的插入/删除，访问数组中的任意一个元素，以及让顺序表自动扩容。

首先需要实现一个顺序表需要使用结构体构造其基本组成部分，以及基本函数接口，采用内部声明外部定义的方式。

// 使用C++手动封装一个顺序表，包含成员数组一个，成员变量N个
#include 
using namespace std;

// 类型重命名方便后续修改数据类型
using datatype = int; // = typedef int datatype;

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

public:
    // 要实现的函数
    // 初始化函数
    void init(int s)
    {
        size = s;                  // 当前数组的最大容量
        data = new datatype(size); // 在堆区申请一个顺序表容器
    }
    // 判空函数
    bool empty();
    // 判满函数
    bool full();
    // 添加数据函数
    bool add(datatype e);
    // 求当前顺序表的实际长度
    int length();
    // 任意位置插入函数
    bool insert_pos(int pos, datatype e);
    // 任意位置删除函数
    bool delete_pos(int pos);
    // 访问容器中任意一个元素 at
    datatype at(int index);
    // 君子函数：二倍扩容
    void expend();
    //打印函数
    void print();
};

函数的内容如下

// 判空函数
bool SeqList::empty()
{
    return len == 0;
}

// 判满函数
bool SeqList::full()
{
    return len == size;
}

// 添加数据函数
bool SeqList::add(datatype e)
{
    if (full())
    {
        expend();
    }
    data[len++] = e;
    return 1;
}

// 求当前顺序表的实际长度
int SeqList::length()
{
    return len;
}

// 任意位置插入函数
bool SeqList::insert_pos(int pos, datatype e)
{
    if (pos < 0 || pos > len)
    {
        cout << "插入位置不合法" << endl;
        return 0;
    }
    else
    {
        if (full())
        {
            expend();
        }
        //移动后面的元素
        for (int i = len; i > pos; i--)
        {
            data[i] = data[i - 1];
        }
        //插入元素
        data[pos] = e;
        len++;
        return 1;
    }
}

// 任意位置函数函数
bool SeqList::delete_pos(int pos)
{
    if (pos < 0 || pos > len)
    {
        cout << "删除位置不合法" << endl;
        return 0;
    }
    else
    {
        //移动后面的元素
        for (int i = pos; i < len; i++)
        {
            data[i] = data[i + 1];
        }
        len--;
        return 1;
    }
}

// 访问容器中任意一个元素 at
datatype SeqList::at(int index)
{
    if (index < 0 || index > len)
    {
        cout << "访问位置不合法" << endl;
        return -1;
    }
    else
    {
        return data[index];
    }
}

//二倍扩容
void SeqList::expend()
{
    // 构造新的数组
    datatype *newData = new datatype[size * 2];

    // 复制旧数组的数据
    for (int i = 0; i < len; i++)
    {
        newData[i] = data[i];
    }
    // 释放旧数组的内存
    delete[] data;
 
    // 更新指针和大小
    data = newData;
    size *= 2;
    cout << "自动扩容" << endl;
}

// 打印列表
void SeqList::print()
{
    for (int i = 0; i < len; i++)
    {
        cout << data[i] << " ";
    }
    cout << endl;
}

测试main函数

int main()
{
    SeqList list;
    list.init (5);
    list.add (1);
    list.add (2);
    list.add (3);
    list.add (4);
    list.add (5);
    list.insert_pos(2,6);
    for (int i = 0; i < list.length(); i++)
    {
        cout << list.at(i) << " ";
    }
    cout << endl;
    list.delete_pos(4);
    list.print();

    return 0;
}

运行结果：