【C++】——用类的形式封装动态顺序表

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Paranoid_cc/article/details/81169143

在前面已经用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;
}

结果图如下：