C++实现动态顺序表

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

typedef int DataType;

class Seqlist
{
    friend ostream& operator<<(ostream&_cout, const Seqlist&s);
public:
    Seqlist()
        :_size(0)
        , _capacity(3)
        , _pdata(new DataType[_capacity])
    {}

    Seqlist(DataType arr[], size_t size)    //数组版构造函数
        :_size(size)
        , _capacity(size)
        , _pdata(new DataType[size])
    {
        //方法一：
        size_t i = 0;
        for (; i < size; i++)
        {
            _pdata[i] = arr[i];
        }
        //方法二：
        memcpy(_pdata, arr, size*sizeof(DataType));
    }

    Seqlist(const Seqlist& s)
        :_size(s._size)
        , _capacity(s._capacity)
        , _pdata(new DataType(s._capacity))
    {
        size_t i = 0;
        for (; i < s._size; i++)
        {
            _pdata[i] = s._pdata[i];
        }
    }

    Seqlist& operator =(const Seqlist& s)
    {
        if (this != &s)
        {
            DataType* tmp = _pdata;
            _pdata = new DataType[s._capacity];
            _size = s._size;
            _capacity = s._capacity;
            delete[] tmp;
            size_t i = 0;
            for (i = 0; i < s._size; i++)
            {
                _pdata[i] = s._pdata[i];
            }
        }
        return *this;
    }

    ~Seqlist()
    {
        if (_pdata != NULL)
        {
            delete[] _pdata;
            _pdata = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

    void PushBack(const DataType& x)
    {
        assert(_pdata);
        CheckCapacity();
        _pdata[_size] = x;
        _size++;
    }
    void PopBack()
    {
        assert(_pdata);
        _size--;
    }

    void Insert(size_t pos, const DataType &x)
    {
        assert(pos >= 0 && pos < _size);
        CheckCapacity();
        size_t i = 0;
        for (i = _size; i>pos; i--)
        {
            _pdata[i] = _pdata[i - 1];
        }
        _pdata[pos] = x;
        _size++;
    }

    void Erase(size_t pos)
    {
        assert(pos >= 0 && pos < _size);
        if (_size == 0)
        {
            return ;
        }
        else
        {
            size_t i = 0;
            for(i = pos; i < _size - 1;i++)
            {
                _pdata[i] = _pdata[i + 1];
            }
            _size--;
        }
    }

    size_t Find(const DataType x)const
    {
        size_t i = 0;
        for (i = 0; i < _size; i++)
        {
            if (_pdata[i] == x)
            {
                return i;
            }
        }
        return -1;
    }

    bool Empty()
    {
        return (_size == 0);
    }
    void Clear()
    {
        if (_pdata != NULL)
        {
            delete[] _pdata;
            _pdata = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

    void  Resize(size_t size, const DataType &x)
    {
        if (size > _size)
        {
            size_t temp = _size;
            _size = size;
            CheckCapacity();
            size_t i = 0;
            for (i = temp; i < size; i++)
            {
                _pdata[i] = x;
            }
        }
        else
        {
            _size = size;
        }
    }


private:
    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            DataType* newspace = new DataType[2 * _capacity];
            size_t i = 0;
            for (; i < _size; i++)
            {
                newspace[i] = _pdata[i];
            }
            delete[] _pdata;
            _pdata = NULL;
            _pdata = newspace;
            _capacity *= 2;
        }
    }

private:
    size_t _size;
    size_t _capacity;
    DataType* _pdata;
};

ostream& operator<<(ostream&_cout, const Seqlist&s)
{
    size_t i = 0;
    for (i = 0; i < s._size; i++)
    {
        _cout << s._pdata[i] << "->";
    }
    return _cout;
}
void test()
{
    int arr[5] = { 0 };
    Seqlist s1;
    Seqlist s2(arr, 5);
    cout << s2 << endl;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.PushBack(5);
    cout << s1 << endl;
    s1.PopBack();
    cout << s1 << endl;
    s1.Insert(2, 5);
    cout << s1 << endl;
    s1.Erase(3);
    cout << s1 << endl;
    s1.Resize(7, 6);
    cout << s1 << endl;
    s1.Resize(3, 0);
    cout << s1 << endl;
}

int main()
{
    test();
    system("pause");
    return 0;
}