模拟实现Vector高级版

总结一下实现Vector时遇到的问题：

1.delete[]的时候总是报错，应当第一时间想到delete[]和new[]的匹配问题，可能由于自己太过自信，没有往那方面想，以至于浪费了好长时间调试代码

2.遇到错误应当现检查逻辑问题，然后再调试，不要浪费时间在寻找错误上，用调试技巧寻找错误会事半功倍。

3.关于数组下标问题，数组下标总是比数组大小少一个

学到的知识：

1.const &是专门引用右值，也可以用&&一般const&与&要成对重载

下面是代码实现：

#include<iostream>
#include<assert.h>
#include<initializer_list>
using namespace std;
typedef unsigned int size_t;
template<class T>
class Vector
{
public:
	typedef T ValueType;
	typedef ValueType* Iterator;
	typedef const ValueType* ConstIterator;
	typedef ValueType& Reference;
	typedef const ValueType& ConstReference;
	typedef size_t SizeType;
	Vector();
	Vector(size_t n,  T&& value = T());
	Vector(initializer_list<T> my);//用不同数字初始化Vector
	Vector(const Vector<T>& v);
	Vector<T>& operator=(const Vector<T>& v);
	virtual ~Vector()
	{
		delete[]this->_start;
	}
	Iterator Begin();
	ConstIterator Begin()const;
	Iterator End();
	ConstIterator End()const;
	SizeType Size()const;
	SizeType Capacity()const;
	bool Empty()const;
	Reference operator[](size_t index);
	ConstReference operator[](size_t index)const;
	Reference Front();
	ConstReference Front()const;
	Reference Back();
	ConstReference Back()const;
	//void PushBack(T&& value);也是引用右值常量，一般成对重载
	void PushBack(const T& value);//const表示引用右值常量；
	void PushBack(T& value);//引用左值变量
	void PopBack();
	Iterator Insert(Iterator pos, const T& value);
	Iterator Erase(Iterator pos);
	void ReSize(SizeType newSize, const T& value = T());
	void Clear()const;

private:
	void CheckCapacity();

protected:
	Iterator _start;
	Iterator _finish;
	Iterator _endOfStorage;
};
template<class T>
Vector<T>::Vector(initializer_list<T> my)
{
	
	this->_start = new T[my.size()];
	_endOfStorage = _start+my.size();
	_finish = _endOfStorage;
	int id = 0;
	for (Iterator i = (Iterator)my.begin(); i<(Iterator)my.end(); i++)//初始化
	{
		_start[id] = *i;
		id++;
	}
}
template<class T>
Vector<T>::Vector() :_start(0), _finish(0), _endOfStorage(0)
{
}
template<class T>
Vector<T>::Vector(size_t n,  T&& value = T()) : _start(new T[n])//new T[]而不是new T()
{
	for (size_t i = 0; i < n; i++)
	{
		_start[i] = value;
	}
	_finish = _start + n;
	_endOfStorage = _finish;
}
template<class T>
bool Vector<T>::Empty()const
{
	return Begin() == End();
}
template<class T>
Vector<T>::Vector(const Vector<T>& v)
{
	size_t len1 = this->_endOfStorage- this->_start;
	size_t len2 = v._finish - v._start;
	_start = new T[len2];
	for (size_t i = 0; i < len2; i++)
	{
		_start[i] = v._start[i];
	}
	_finish = _start + len2;
	_endOfStorage = _finish;
}
template<class T>
T& Vector<T>::operator[](size_t index)
{
	assert(index < size());
	return start[index];
	
}
template<class T>
const T& Vector<T>::operator[](size_t index)const 
{
	assert(index < size());
	return start[index];

}
template<class T>
size_t Vector<T>::Capacity()const
{
	return _endOfStorage - _start;
}
template<class T>
size_t Vector<T>::Size()const
{
	return _finish - _start;
}
template<class T>
T* Vector<T>::Begin()
{
	return _start;
}
template<class T>
T& Vector<T>::Front()
{
	return *Begin();
}
template<class T>
T& Vector<T>::Back()
{
	return *(End() - 1);
}
template<class T>
const T* Vector<T>::Begin()const 
{
	return _start;
}
template<class T>
T* Vector<T>::End()
{
	return _finish;
}
template<class T>
const T* Vector<T>::End()const
{
	return _finish;
}
template<class T>
Vector<T>& Vector<T>::operator=(const Vector<T>& v)
{
	size_t len1 = this->_endOfStorage - this->_start;
	size_t len2 = v._finish - v._start;
	if (len1<len2)
	{
		Iterator temp = new T[len2];
		delete _start;
		_start = temp;
	}
	for (size_t i = 0; i < len2; i++)
	{
		_start[i] = v._start[i];
	}
	_finish = _start + len2;
	_endOfStorage = _finish;
	return *this;
}
template<class T>
void Vector<T>::CheckCapacity()
{
	if (_finish >= _endOfStorage)
	{
		int newCapacity = Capacity() + 3;
		Iterator pTemp = new T[newCapacity];
		size_t size = _finish - _start;
		memcpy(pTemp, _start, sizeof(T)*size);
		if (NULL != _start)
		{
			delete[] _start;
		}
		_start = pTemp;
		_finish = _start + size;
		_endOfStorage = _start + newCapacity;
	}
}
template<class T>
void Vector<T>::PushBack(const T& value)//const引用常量，
{
	CheckCapacity();
	*_finish = value;
	_finish += 1;
}
template<class T>
void Vector<T>::PushBack(T& value)//引用左值变量
{
	CheckCapacity();
	*_finish = value;
	_finish += 1;
}
template<class T>
void Vector<T>::PopBack()
{
	assert(0 != Size());
	_finish -= 1;
}
template<class T>
T* Vector<T>::Insert(Iterator pos, const T& value)
{
	size_t nPos=pos-_start;
	CheckCapacity();
	
	if (nPos <= Size() && nPos >= 0)
	{
		for (size_t i=Size()-1; i >=nPos; i--)//下标从0开始所以Size()-1;,需要把nPos位置后移所以>=;
		{
			_start[i+1] = _start[i];
		}
		_start[nPos] = value;
		_finish += 1;
		return pos;
	}
	return NULL;
}
template<class T>
void Vector<T>::ReSize(SizeType newSize, const T& value = T())
{
	if (newSize < Size())
	{
		_endOfStorage = _start + newSize;
		_finish = _endOfStorage;
	}
	else
	{
		Iterator Temp = new T[newSize];
		delete []_start;
		_start = Temp;
		_finish = _start + newSize;
		_endOfStorage = _finish;
	}
	for (size_t i = 0; i < Capacity(); i++)
	{
		_start[i] = value;
	}
}
template<class T>
T* Vector<T>::Erase(Iterator pos)
{
	size_t nPos = pos - _start;
	if (nPos <= Size() && nPos >= 0)
	{
		for (size_t i = nPos; i<Size(); i++)
		{
			_start[i] = _start[i+1];
		}
		_finish -= 1;
		return pos;
	}
	return NULL;
}
template<class T>
void show(Vector<T> arr)
{
	Vector<int>::Iterator it;
	for (it = arr.Begin(); it != arr.End(); it++)
	{
		cout <<" "<<*it;
	}
	cout << endl;
}
void FunTest1()
{
	Vector<int>err{ 1, 2, 3, 4 };
	show(err);//1 2 3 4
}
void FunTest2()
{
	Vector<int>err(4,5);
	err.PushBack(10);
	show(err);//5 5 5 5 10
	err.PopBack();
	show(err);//5 5 5 5 
}
void FunTest3()
{
	Vector<int>arr{ 1, 2, 3, 4 };
	Vector<int>brr(arr);
	Vector<int>crr;
	Vector<int>drr;
	drr = crr = brr;
	drr.Erase(drr.Begin() + 2);
	show(drr);//1 2 4
	drr.Insert(drr.Begin() + 2, 3);
	show(drr);
}
void FunTest4()
{
	Vector<int>arr{ 1, 2, 3, 4 };
	show(arr);
	cout << arr.Back() << endl;
	cout << arr.Front() << endl;
	arr.ReSize(3, 10);
	int a = 2345;
	arr.PushBack(a);
	arr.PushBack(100);
	show(arr);//10 10 10 2345 100
}
int main()
{
	//FunTest1();
	//FunTest2();
	//FunTest3();
	FunTest4();
	system("pause");
}