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;
}