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