顺序表的实现

#include<iostream>
using namespace std;
#include<cassert>
typedef  int DataType;

class SeqList
{
public:
    SeqList()
        : _array(NULL)
        , _size(0)
        , _capacity(0)
    {
        cout << "SeqList()" << endl;
    }
    SeqList(DataType* a, size_t size)
        : _array(new DataType[size])
        , _size(size)
        , _capacity(size)
    {
        cout << "SeqList()" << endl;
        memcpy(_array, a, sizeof(DataType)*size);
    }
    ~SeqList()
    {
        if (_array)
        {
            delete[] _array;
            _array = NULL;
            _size = 0;
            _capacity = 0;
        }
        cout << "~SeqList()" << endl;
    }
    /*SeqList(const SeqList &s)
    {
        _array = new DataType[s._size];
        memcpy(_array, s._array, sizeof(DataType)*s._size);
        _size = s._size;
        _capacity = s._capacity;
    }*/
    SeqList(const SeqList &s)
        :_array(NULL)
        , _size(0)
        , _capacity(0)
    {
        SeqList tmp (s._array,s._size);
        tmp.Swap(*this);
    }
    void Swap(SeqList &s)
    {
        std::swap(_array, s._array);
        std::swap(_size, s._size);
        std::swap(_capacity, s._capacity);
    }
    SeqList& operator=(const SeqList &s)
    {
        if (this != &s)
        {
            delete[] _array;
            _array = new DataType[s._size];
            _size = s._size;
            _capacity = s._capacity;
        }
        return *this;
    }
public:
    void PushBack(DataType x)
    {
        _CheckCapacity(_size);
        _array[_size] = x;
        _size++;
    }

    void PushFront(DataType x)
    {
        _CheckCapacity(_size);
        for (size_t i = _size; i >0; --i)
        {
            _array[i] = _array[i - 1];
        }
        _array[0] = x;
        _size++;
    }

    void Insert(DataType x, size_t Pos)
    {
        _CheckCapacity(_size);
        if (Pos <= 0 || Pos>_size)
        {
            cout << "插入位置不合法" << endl;
        }
        else
        {
            for (size_t i = _size; i > Pos; --i)
            {
                _array[i] = _array[i-1];
            }
            _array[Pos] = x;
            ++_size;
        }
    }

    void PopFront()
    {
        assert(_array);
        if (_size <= 0)
        {
            cout << "顺序表为空。" << endl;
        }
        else
        {
            for (size_t i = 1; i <_size; ++i)
            {
                _array[i - 1] = _array[i];
            }
            _size--;
        }
        
    }

    void PopBack()
    {
        assert(_array);
        if (_size <= 0)
        {
            cout << "顺序表为空。" << endl;
        }
        else
        {
            _size--;
        }
        
    }

    void Erase(size_t Pos)
    {
        assert(_array);
        if (_size <= 0)
        {
            cout << "顺序表为空。" << endl;
        }
        else if (Pos <= 0 || Pos>_size)
        {
            cout << "指定位置不合法" << endl;
        }
        else
        {
            for (size_t i = Pos; i < _size-1; ++i)
            {
                _array[i] = _array[i + 1];
            }
            _size--;
        }
    }

    int Find(const DataType& x)
    {
        assert(_array);
        size_t result=0;
        for (size_t i = 0; i < _size; i++)
        {
            if (_array[i] == x)
            {
                result = i;
                break;
            }
            else
            {
                result = -1;
            }
        }
        if (result == -1)
        {
            cout << "顺序表中没有要查找的数据。" << endl;
        }
        return result;
    
    }

    void Print()
    {
        for (size_t i = 0; i < _size; i++)
        {
            cout << _array[i] << " ";
        }
        cout << endl;
    }

private:
    void  _CheckCapacity(size_t size)
    {
        if (size >= _capacity)
        {
            _capacity = size > _size * 2 ? size : _capacity * 2;
            DataType* tmp = new DataType[_capacity];
            memcpy(tmp, _array, sizeof(DataType)*_size);
            delete[] _array;
            _array = tmp;
        }
    }
private:
    DataType* _array;
    size_t _size;
    size_t _capacity;
};

void Test1()
{
    int array[5] = { 0, 1, 2, 3, 4 };
    SeqList s1(array, 5);
    cout << "原顺序表：" << endl;
    s1.Print();
    cout << "PushBack：" << endl;
    s1.PushBack(5);
    s1.PushBack(6);
    s1.PushBack(7);
    s1.PushBack(8);
    s1.PushBack(9);
    s1.PushBack(10);


    s1.Print();

    cout << "PushFront(5)：" << endl;
    s1.PushFront(5);
    s1.Print();

    cout << "Insert(5,2)：" << endl;
    s1.Insert(5,2);
    s1.Print();

}

void Test2()
{
    int array[5] = { 0, 1, 2, 3, 4 };
    SeqList s2(array, 5);
    cout << "原顺序表：" << endl;
    s2.Print();
    cout << "PopFront()：" << endl;
    s2.PopFront();
    s2.PopFront();
    //s2.PopFront();
    s2.Print();

    cout << "PopBack()：" << endl;
    s2.PopBack();
    s2.PopBack();
    //s2.PopBack();
    //s2.PopBack();
    s2.Print();

    cout << "Erase(2)：" << endl;
    s2.Erase(2);
    s2.Print();
}

void Test3()
{
    int array[5] = { 8, 3, 4, 6, 5 };
    SeqList s3(array, 5);
    cout << "原顺序表：" << endl;
    s3.Print();

    cout << "查找3所对应的位置：" << s3.Find(3) << endl;
    cout << "查找9所对应的位置：" << s3.Find(9) << endl;

}
int main()
{
    Test1();
    Test2();
    Test3();
    return 0;
}