C++动态顺序表

#include<string.h>
#include <iostream>
#include<assert.h>
#include<stdio.h>
using namespace std;
typedef int DataType;

class SeqList
{
public:
    SeqList(size_t capacity = 10)         //构造
        :_array(new int[10])
        ,_size(0)
        ,_capacity(10)
    {

    }

    SeqList(const SeqList& s)            //拷贝构造
        :_array(NULL)
        ,_size(0)
        ,_capacity(0)
    {
        SeqList tmp(s._capacity);
        _size = tmp._size;
        _capacity = tmp._capacity;
        swap(_array, tmp._array);   
    }

    SeqList& operator=(const SeqList& s)  //赋值
    {
        if (this != &s)
        {
            SeqList tmp(s._capacity);
            _size = tmp._size;
            _capacity = tmp._capacity;
            swap(_array, tmp._array);
        }
        return *this;
    }

    void Print()
    {
        for (unsigned int i = 0; i < _size; i++)
        {
            cout << _array[i] << " ";
        }
        printf("\n");
    }

    ~SeqList()                           //析构，销毁
    {
        if (_array != NULL)
        {
            delete[] _array;
            _array = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

    void PushBack(DataType data)          //尾插
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }

    void PopBack()                       //尾删
    {
        if(_size > 0)
        {
            _size--;
        }
    }

    void Insert(size_t pos, DataType data)//任意位置插入
    {
        assert(pos >= 0 && pos<_size);
        CheckCapacity();
        size_t i = 0;
        for (i = _size; i>pos; i--)
        {
            _array[i] = _array[i - 1];
        }
        _array[pos] = data;
        _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++)
            {
                _array[i] = _array[i + 1];
            }
            _size--;
        }
    }

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

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

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

    DataType& operator[](size_t index)              //可读可写
    {
        return _array[index];
    }


private:
    void CheckCapacity()                  //检测容量
    {
        if (_size >= _capacity)
        {
            int *newspace = new int[2 * _capacity];
            size_t i = 0;
            for (i = 0; i < _size; i++)
            {
                newspace[i] = _array[i];
            }
            delete[] _array;
            _array = newspace;
            _capacity *= 2;
        }
    }
    DataType* _array;
    size_t _size;
    size_t _capacity;
};

int main()
{
    SeqList s1;
    SeqList s2(s1);
    SeqList s3;
    s3 = s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.Insert(1, 6);
    s1[2] = 7;
    cout << s1[3]<<endl;
    s1.Erase(2);
    s3.PushBack(4);
    s2.PushBack(4);
    s1.Print();
    s2.Print();
    s3.Print();
}