用模板类实现顺序表

#pragma once
#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;

template<class T>
class Vector
{
private:
T* _start;
T* _finish;
T* _endOfStorage;
private:
//如果容量小于顺序表的大小，则增容
void _CheckCapacity()
{
size_t oldsize = Size();
size_t capacity = Capacity();
if (Size() >= _capacity)
size_t newcapacity = 2 * capacity + 3;
//申请新空间
T* temp = new T[newCapacity];
//拷贝元素
memcpy(temp, _start, size*sizeof(T));
//释放
if (_start)
{
delete[] _start;
_start = temp;
_finish = _start + newsize;
_endOfStorage = _finish;
}
}
public:
Vector()//无参构造函数
{
_start = NULL;
_finish = 0;
_endOfStorage = 0;
}
Vector(const T* array, size_t size)//有参构造函数
{
_start = T[size];
_finish = _start + size;
_endOfStorage = _start + size;
assert(NULL != array);
//易出错
//memcpy(_start,array,size*sizeof(T));
//效率低
for (size_t i = 0; i < size; ++i)
_start[i] = array[i];
}
Vector(const Vector& v)//拷贝构造函数
:_start(new T[v.Size()])
{
_size_t size = v.Size();
_start = new T[size];
for (size_t i = 0; i < size; i++)
_start[i] = v[i];
_finish = _start + size;
_endOfStorage = _finish;
}
Vector<T>& operator=(const Vector& s)//重载
{
if (this != &s)
{
T* temp = new T[s._capacity];
for (size_t i = 0; i < s._size; i++)
temp[i] = s._data[i];
delete[] s._data;
_data = temp;
_size = s._size;
_capacity = s._size;
}
return *this;
}
~Vector()//析构函数
{
if (_start != NULL)
{
delete[] _start;
}
_start = _finish = _endOfStorage = 0;
}
size_t Size()const//返回顺序表的长度
{
return _finish-_start;
}
size_t Capacity()const//返回顺序表的容量
{
return _endOfStorage-_capacity;
}
void PushBack(const T& d)//尾插
{
_CheckCapacity();
*_finish++ = d;
}
void PopBack()//尾删
{
--_finish;
}
void Insert(size_t pos, const T& d)//在位置pos处插入数值d
{
assert(pos <= Size());
_CheckCapacity();
//搬元素
for (size_t i = Size(); i > pos; --i)
_start[i] = _start[i-1];
/*for (size_t i = Size()-1 ; i >= pos; --i)
_data[i+1] = _data[i];*/
//插入元素d
_start[pos] = d;
_finish++;
}
void Erase(size_t pos)//删除位置pos的元素
{
assert(pos <= Size());
for (size_t i = pos; i < Size() - 1; i++)
_start[i] = _start[i + 1];
_finish--;
}
bool Empty()const//判空
{
return 0 == Size();
}
//实现下标访问
T& operator[](size_t index)
{
return _start[index];
}
const T& operator[](size_t index)const
{
return _start[index];
}
//返回顺序表的第一个元素
T& Front()
{
return _start[0];
}
const T& Front()const
{
return _start[0];
}
//返回顺序表的最后一个元素
T& Back()
{
return _start[Size() - 1];
}
const T& Back()const
{
return _start[Size() - 1];
}
void Resize(size_t newsize, const T& d = T())//将顺序表中的元素个数变成newSize
{
size_t oldsize = Size();
if (oldsize >= newsize)
_finish = _start + newsize;
else if (newsize > oldsize && newsize < Capacity())
{
for (size_t i = oldsize; i < newsize; i++)
_start[i] = d;
_finish = _start + newsize;
}
else
{
T* temp = newsize;
//旧空间的元素搬到新空间
for (size_t i = 0; i < oldsize; i++)
temp[i] = _start[i];
//新空间中多出来的空间放d
for (size_t i = oldsize; i < newsize; i++)
temp[i] = d;
//释放旧空间
delete[] _start;
_start = temp;
_finish = _start + newsize;
_endOfStorage = _finish;
}
}
void clear()//清空
{
_finish = _start;
}
void Display()//打印
{
if (_start == NULL)
return;
size_t size = Size();
size_t capacity = Capacity();
for (size_t i = 0; i < size; i++)
{
cout << _start[i] << " ";
}
cout << endl;
}
};
int main()
{
int arr[] = { 1, 2, 3, 4, 5 };
int sz = sizeof(arr) / sizeof(arr[0]);
Vector<int> s1(arr, sz);
s1.Display();

s1.PushBack(1);
s1.PushBack(1);
s1.PushBack(1);
s1.PushBack(1);
s1.Display();

s1.PushBack(7);//尾插
s1.Display();

s1.PopBack();//尾删
s1.PopBack();
s1.Display();

s1.Insert(2, 9);//指定位置插入
s1.Display();

s1.Erase(2);//指定位置删除
s1.Display();

s1.Resize(6, 10);
s1.Display();
s1.Resize(4);
s1.Display();
s1.Resize(10);
s1.Display();

s1.clear();
s1.Display();
system("pause");
return 0;
}