向量类模板的实现

任务描述

向量类模板的实现。

相关知识

为了完成本关任务，你需要：
1.理解STL中容器的概念。
2.数组的基本操作。如数组元素的随机访问、基于指针的元素的插入、基于指针的元素的删除。
3.理解迭代器的概念，如何针对不同的容器实现其迭代器。
4.基于函数模板的通用算法的实现。

编程要求

根据提示，在右侧编辑器补充代码，完成向量类模板的成员函数的功能。

测试说明

平台会对你编写的代码进行测试：

测试输入：无；
预期输出：
The original numbers are:
0 1 2 3 4 5 6 7 8 9
after erasing the first:
1 2 3 4 5 6 7 8 9
after insert 999:
1 2 3 999 4 5 6 7 8 9
The elements in Vector V1 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6 6
The elements in Vector V2 are:
2 3 4 1000 5 6 7 8 9 10 6 6 6 6

 

#pragma once
template <typename T>
class Vector

{
private:
	T* data;
	int size;
	int max;
public:
	enum { SPARE_MAX = 16 };  //此处将最大值改小点，测试代码的问题。
	explicit Vector(int n = 0) :size(0), max(n + SPARE_MAX)
	{
		data = new T[max];
	}

	Vector(const Vector& v)
	{
		data=v.data;
		size=v.size;
		max=v.max;
	}

	~Vector() { delete[] data; }

	Vector& operator=(const Vector& v);

	T& operator[](int id) { return data[id]; }
	const T& operator[](int id) const { return data[id]; }

	bool Empty() const { return size == 0; }
	int Size() const{ return size; }
	int Max() const { return max; }
	void Clear() { size = 0; }

	typedef T* iterator;     //迭代器
	typedef const T* const_iterator;    //常量型迭代器
	iterator Begin() { return data; }
	const_iterator Begin() const { return data; }
	iterator End() { return data + size; }
	const_iterator End() const{ return data + size; }

	T& Front() { return data[0]; }
	const T& Front() const { return data[0]; }
	T& Back() { return data[size - 1]; }
	const T& Back() const { return data[size - 1]; }

	void Push_back(const T& item);
	void Pop_back()
	{
		if (!Empty()) size--;
	}

	void Reserve(int newMax);  //扩大数组容量为newMax，并保留原来的数据
	void Resize(int newSize, const T& item = T());   //把数据个数增加为newSize,保留原来的数据，其余的值为item

	iterator Insert(iterator itr, const T& item = T()); //在itr所指向的位置插入item
	iterator Erase(iterator itr); //删除itr所指向的元素
};

//赋值运算符重载
/************Begin***********************/
template<typename T>
Vector<T>& Vector<T>::operator=(const Vector& v)
{
	delete[]data;
	data=new T[v.max];
	size=v.size;
	max=v.max;
	for(int i=0;i<size;i++)
	data[i]=v.data[i];
	return *this;
}                                       
                                       
/************End*************************/

//尾部插入数据
/************Begin***********************/
template<typename T>
void Vector<T>::Push_back(const T& item)
{
	data[size++]=item;
}                                       
                                       
/************End*************************/

//扩大数组容量为newMax，并保留原来的数据
/************Begin***********************/
template<typename T>
void Vector<T>::Reserve(int newMax)
{
	if(newMax<=max)
	{
		return;
	}
	T* old=data;
	data=new T[newMax];
	for(int i=0;i<size;i++)
	{
		data[i]=old[i];
	}
	max=newMax;
	delete[]old;
}                                       
                                       
/************End*************************/

//把数据个数增加为newSize,保留原来的数据，其余的值为item
/************Begin***********************/
template<typename T>
void Vector<T>::Resize(int newSize,const T& item)
{
	if(newSize>max)
	Reserve(2*newSize+1);
	for(int i=size;i<newSize;i++)
	data[i]=item;
	size=newSize;
}                                       
                                       
/************End*************************/
                                       
//基于指针插入数据
/************Begin***********************/
template<typename T>
typename Vector<T>::iterator Vector<T>::Insert(iterator itr,const T&item)
{
	if(size==max)
	{
		Reserve(size*2+1);
	}
	for(iterator p=data+size,q=data+size-1;p!=itr;--p,--q)
	{
		*p=*q;
	}
	*itr=item;
	size++;
	return itr;
}                                       
                                       
/************End*************************/

//基于指针删除数据
/************Begin***********************/
template<class T>
typename Vector<T>::iterator Vector<T>::Erase(iterator itr)
{
	for(iterator p=itr,q=itr+1;q!=data+size;++p,++q)
	{
		*p=*q;
	}
	size--;
	return itr;
}
                                       
/************End*************************/