C++使用模板实现顺序表

#pragma once 
#include<iostream>
using namespace std;
#include<stdlib.h>
#include<assert.h>
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)
    {
        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& operator=(const SeqList& s)
    {
        if (this->_pData)
        {
            _pData = new DataType[];
            memcpy(_pData, s._pData, sizeof(DataType)*s._size);
        }
    }

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

    DataType Find(DataType data)  //查找
    {
        for (DataType j = 0; j <= (DataType)_size; j++)
        {
            if (data == _pData[j])
            {
                return 1;
            }
        }
        return -1;
    }
        // 参数检测 
    void Insert(size_t pos, DataType data) //插入
    {
        if (pos > _size)
            return;
        CheckCapacity();
        size_t end = _size;
        while (end >= pos)
        {
            _pData[end + 1] = _pData[end];
            --end;
        }
        _pData[pos] = data;
        ++_size;
    }

    void Erase(size_t pos) //固定位置删除
    {
        assert(pos <= _size);
        size_t end = _size;
        while (pos < end)
        {
            _pData[pos] = _pData[pos + 1];
            pos++;
        }
        --_size;
    }
    size_t Size()const  //返回顺序表的大小
    {
        return _size;
    }
    size_t Capacity()const  //返回顺序表的当前容量
    {
        return _capacity;
    }
    bool Empty()const   //判断顺序表是否为空
    {   
            return 0 == _size;
    }
        // 将顺序表中的元素改成newSize 

    DataType& operator[](size_t index)  
    {
        assert(index < _size);
        return _pData[index];
    }

    const DataType& operator[](size_t index)const
    {
        return _pData[index];
    }


    DataType& Front()  // 获取顺序表中第一个元素 
    {
        return _pData[0];
    }

    const DataType& Front()const  // 获取顺序表中第一个元素 
    {
        if (_size)
        {
            return _pData[0];
        }
        else
            return NULL;
    }


    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 + 3;
            DataType* pTemp = new DataType[NewCapacity];
            for (size_t i = 0; i < _size; ++i)
            {
                pTemp[i] = _pData[i];   
            }

            delete _pData;
            _pData = pTemp;
            _capacity = NewCapacity;
        }
    }

    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;
            _size = newSize;
        }
        else
        {
            DataType* pTemp = new DataType[newSize];
            for (size_t i = 0; i < _size; ++i)
                pTemp[i] = _pData[i];

            for (size_t i = _size; i < newSize; ++i)    
                pTemp[i] = data;

            delete _pData;
            _pData = pTemp;
            _capacity = newSize;
            _size = newSize;
        }
    }
    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 TestSeqList()
{
    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(20);
    cout << s1 << endl;
    cout << s1.Size() << endl;
    cout << s1.Capacity() << endl;
}

int main()
{
    TestSeqList();
    return 0;
}

运行结果：