在前面已經用C語言實現過了
https://blog.csdn.net/Paranoid_cc/article/details/79773441
今天用另一種語言C++ 以類的形式來實現一下

順序表是在計算機記憶體中以陣列的形式儲存的線性表，線性表的順序儲存是指用一組地址連續的儲存單元依次儲存線性表中的各個元素、使得線性表中在邏輯結構上相鄰的資料元素儲存在相鄰的物理儲存單元中，即通過資料元素物理儲存的相鄰關係來反映資料元素之間邏輯上的相鄰關係，採用順序儲存結構的線性表通常稱為順序表。順序表是將表中的結點依次存放在計算機記憶體中一組地址連續的儲存單元中。

#define _CRT_SECURE_NO_WARNINGS
 


#include<iostream>
#include<string.h>
#include<assert.h>
using namespace std;

typedef int DataType;
class SeqList
{
public:
    SeqList()    //建構函式
        : _pData(new DataType[3])
        , _capacity(3)
        , _size(0)
    {}

    SeqList(DataType* array, size_t size)//建構函式
        :_pData(new
 
 DataType[size])
        , _capacity(size)
        , _size(size)
    {
        //拷貝方式1
        //memcpy(_pData, array, sizeof(DataType)*size);

        //拷貝方式2
        for (size_t i = 0; i < size; ++i)
            _pData[i] = array[i];
    }

    SeqList(const SeqList& s)//拷貝建構函式
    {
        _pData = new
 
 DataType[s._size];
        _capacity = s._size;
        _size = s._size;
        for (size_t i = 0; i < s._size; ++i)
            _pData[i] = s._pData[i];
    }

    ~SeqList()//解構函式
    {
        if (_pData)
        {
            delete[] _pData;
            _pData = NULL;
            _size = 0;
            _capacity = 0;
        }
    }
    ////////////////////////////////////////////////////////////////////
    void PushBack(const DataType& data)//尾插
    {
        CheckCapacity();
        _pData[_size++] = data;
    }

    void PopBack()//尾刪
    {
        assert(_size);
        --_size;
    }

    void Insert(size_t pos, DataType data)//任意位置插入
    {
        if (pos > _size)
            return;
        CheckCapacity();

        //搬移元素
        for (int i = _size - 1; i >= pos; --i)
            _pData[pos] = data;

        _pData[pos] = data;
        ++_size;
    }

    void Erase(size_t pos)//任意位置刪除
    {
        if (pos >= _size)
            return;

        //搬移元素
        for (size_t i = pos; i < _size - 1; ++i)
            _pData[i] = _pData[i + 1];

        --_size;
    }

    size_t Size()const          //大小
    {
        return _size;
    }

    size_t Capacity()const      //容量
    {
        return _capacity;
    }

    bool Empty()const          //判空
    {
        return 0 == _size;
    }

    void ReSize(size_t newSize,DataType data=DataType())//改變順序表的元素個數
    {
        if (newSize < _size)//縮小
            _size = newSize;
        //增大，但在自身範圍之內，多增的元素可以放下
        else if (newSize >= _size && newSize < _capacity)//增大，但可以放得下
        {
            for (size_t i = _size; i < newSize; ++i)
                _pData[i] = data;//增加的都用data填充
            _size = newSize;
        }
        else//多出來的，自身容量放不下，要開闢空間
        {
            DataType* pTemp = new DataType[newSize];//開闢新空間
            //把原空間的元素拷過來
            for (size_t i = 0; i < _size; ++i)
                pTemp[i] = _pData[i];
            //原來的元素搬移完之後，還有多出來的空間用data填充
            for (size_t i = _size; i < newSize; ++i)
                pTemp[i] = data;
            //釋放舊空間
            delete[] _pData;
            _pData = pTemp;//指向新空間
            _capacity = newSize;
            _size = newSize;
        }
    }
    ///////////////////////////////////////////////////////////////////////
    DataType& operator[](size_t index)//下標運算子過載
    {
        assert(index < _size);
        return _pData[index];
    }
    //後面是const 前面返回值是引用 一定要用const（外界接收時可能就被修改掉了）
    const DataType& operator[](size_t index)const//下標運算子過載
    {
        return _pData[index];
    }

    DataType& Front() //獲取第一個元素
    {
        return _pData[0];
    }
    const DataType& Front()const //獲取第一個元素
    {
        return _pData[0];
    }

    DataType& Back()//獲取最後一個元素
    {
        return _pData[_size - 1];
    }
    const DataType& Back()const//獲取最後一個元素
    {
        return _pData[_size - 1];
    }

    void Clear()//將順序表中所有元素清空（不會改變容量）
    {
        _size = 0;
    }

    void CheckCapacity()//檢測容量
    {
        if (_size >= _capacity)
        {
            //開闢新空間
            size_t newCapacity = _capacity * 2;
            DataType* pTemp = new DataType[newCapacity];
            //搬移元素
            for (size_t i = 0; i < _size; ++i)
                pTemp[i] = _pData[i];

            delete _pData;//釋放舊空間
            _pData = pTemp;//指向新空間
            _capacity = newCapacity;
        }
    }

    friend ostream& operator<<(ostream& _cout, const SeqList& s)//列印函式
    {
        for (size_t i = 0; i < s._size; ++i)
        {
            cout << s._pData[i] << " ";
        }
        return _cout;
    }

private:
    DataType* _pData;
    size_t _capacity;//最大元素的個數
    size_t _size;//有效元素的個數
};

void Test()
{
    int array[] = { 1, 2, 3, 4};
    SeqList s1(array, sizeof(array) / sizeof(array[0]));

    s1.PushBack(5);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;

    s1.ReSize(2);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;

    s1.ReSize(6);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;

    s1.ReSize(10);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;

    s1.Erase(1);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;
}

結果圖如下：