模拟实现vector类

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

template<class T>
class Vector
{
public:
	//迭代器类型: T*
	typedef T* iterator;
	typedef const T* const_iterator;

	Vector()
		:_start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{}

	Vector(size_t n, const T& val = T())
		:_start(new T[n])
		,_finish(_start + n)
		,_endOfStorage(_start + n)
	{
		for (size_t i = 0; i < n; ++i)
		{
			_start[i] = val;
		}
	}

	template<class InputIterator>
	Vector(InputIterator first, InputIterator last)
		:_start(nullptr)
		,_finish(nullptr)
		,_endOfStorage(nullptr)
	{
		while (first != last)
		{
			pushBack(*first);
			first++;
		}
	}

	void pushBack(const T& val)
	{
		//检查容量
		if (_finish = _endOfStorage)
		{
			size_t newC = nullptr ? 1 : 2 * capacity();
			reserve(newC);
		}
		//插入
		*_finish = val;
		//更新
		_finish++;
	}

	void reserve(size_t n)
	{
		if (n > capacity())
		{
			//保存有效元素个数
			size_t sz = size();
			//申请空间	
			T* tmp = new T[n];
			//拷贝内容
			if (_start)
			{
				//拷贝有效元素，如果是自定义类型则会发生浅拷贝
				//memcpy(tmp, _start, size() * sizeof(T));
				for (size_t i = 0; i < sz; i++)
				{
					//调用当前数据的赋值运算符重载函数完成深拷贝
					tmp[i] = _start[i];
				}
				//释放原有空间
				delete[] _start;
			}
			//更新
			_start = tmp;
			_finish = _start + sz;
			_endOfStorage = _start + n;
		}
	}

	size_t size() const
	{
		return _finish - _start;
	}

	size_t capacity() const
	{
		return _endOfStorage - _start;
	}

	iterator begin()
	{
		return _start;
	}

	iterator end()
	{
		return _finish;
	}

	const_iterator begin() const
	{
		return _start;
	}

	const_iterator end() const
	{
		return _finish;
	}

	T& operator[](size_t pos)
	{
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos) const
	{
		assert(pos < size());
		return _start[pos];
	}

	void resize(size_t n, const T& val = T())
	{
		//n > capacity
		if (n > capacity())
		{
			reserve(n);
		}
		//size < n <= capacity
		if (n > size())
		{
			//[size, n)：填充val
			while (_finish != _start + n)
			{
				*_finish = val;
				++_finish;
			}
		}
		//n <= size
		_finish = _start + n;
	}

	void insert(iterator pos, const T& val)
	{
		//检查位置
		assert(pos >= _start && pos <= _finish);
		//检查容量
		if (_finish == _endOfStorage)
		{
			//增容会导致迭代器失效
			//保存pos和_start的偏移量
			size_t offset = pos - _start;
			size_t newC = _endOfStorage == nullptr ? 1 : 2 * capacity();
			reserve(newC);
			//更新pos
			pos = _start + offset;
		}
		//移动元素：从后向前
		iterator end = _finish;
		while (end != pos)
		{
			*end = *(end - 1);
			--end;
		}
		//插入
		*pos = val;
		//更新
		++_finish;
	}

	//返回值：指向被删除元素的下一个位置
	iterator erase(iterator pos)
	{
		//检查范围
		assert(pos >= _start && pos < _finish);
		//元素移动
		iterator begin = pos + 1;
		while (begin != _finish)
		{
			//从前向后
			*(begin - 1) = *begin;
			begin++;
		}
		//更新
		--_finish;
		return pos;
	}

	//尾删
	void popBack()
	{
		if (size() > 0)
		{
			erase(end() - 1);
		}
	}

	~Vector()
	{
		if (_start)
		{
			delete[] _start;
			_start = _finish = _endOfStorage = nullptr;
		}
	}

private:
	//_start:第一个元素的首地址
	iterator _start;
	//_finish:最后一个有效元素的结尾
	iterator _finish;
	//_endOfStorage:空间的结尾
	iterator _endOfStorage;
};

template<class T>
void printVector(Vector<T>& vec, const T& val)
{
	Vector::iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		*it = val;
		it++;
	}
	cout << endl;
}

template<class T>
void printVector(const Vector<T>& vec)
{
	Vector::iterator it = vec.begin();
	while (it != vec.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

template<class T>
void printVectorFor(Vector<T>& vec, const T& val)
{
	for (auto& e : vec)
	{
		cout << e << " ";
		e = val;
	}
	cout << endl;
}

template<class T>
void printVectorFor(const Vector<T>& vec)
{
	for (const auto& e : vec)
	{
		cout << e << " ";
	}
	cout << endl;
}

template<class T>
void printOperator(Vector<T>& vec, const T& val)
{
	for (size_t i = 0; i < vec.size(); ++i)
	{
		cout << vec.operator[](i) << " ";
		vec[i] = val;
	}
	cout << endl;
}

template<class T>
void printOperator(const Vector<T>& vec)
{
	for (size_t i = 0; i < vec.size(); ++i)
	{
		cout << vec.operator[](i) << " ";
	}
	cout << endl;
}