vector的模拟实现

1. vector是表示可变大小数组的序列容器。
2. 就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。
3. 本质讲，vector使用动态分配数组来存储它的元素。当新元素插入时候，这个数组需要被重新分配大小。为了增加存储空间，其做法是，分配一个新的数组，然后将全部元素移到这个数组。就时间而言，这是一个相对代价高的任务，因为每当一个新的元素加入到容器的时候，vector并不会每次都重新分配大小。
4. vector分配空间策略：vector会分配一些额外的空间以适应可能的增长，因为存储空间比实际需要的存储空间更大。不同的库采用不同的策略权衡空间的使用和重新分配。但是无论如何，重新分配都应该是对数增长的间隔大小，以至于在末尾插入一个元素的时候是在常数时间的复杂度完成的。
5. 因此，vector占用了更多的存储空间，为了获得管理存储空间的能力，并且以一种有效的方式动态增长。
6. 与其它动态序列容器相比（deques, lists and forward_lists）， vector在访问元素的时候更加高效，在末尾添加和删除元素相对高效。对于其它不在末尾的删除和插入操作，效率更低。比起lists和forward_lists统一的迭代器和引用更好。

部分接口实现

#include <string.h>
#include <assert.h>

template<class T>
class Vector
{
public:
	// Vector的迭代器是一个原生指针
	typedef T* Iterator;
	typedef const T* ConstIterator;
	Vector()
		: _start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{}
	Vector(size_t size, const T& val = T())
		: _start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{
		reserve(size);
		while (size--) {
			push_back(val);
		}
	}
	//拷贝构造
	Vector(const Vector<T>& val)
		: _start(nullptr)
		, _finish(nullptr)
		, _endOfStorage(nullptr)
	{
		
		reserve(val.capacity());
		Iterator it = val._start;
		while (it != val._finish) {
			*_finish = *it;
			_finish++;
			it++;
		}
		_endOfStorage = _start + val.capacity();
	}

	//重载[]
	T& operator[](size_t pos)
	{
		return _start[pos];
	}

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

	//重载=
	Vector<T>& operator=(const Vector<T> tmp);


	//begin
	Iterator begin()
	{
		return _start;
	}

	//end
	Iterator end()
	{
		return _finish;
	}

	ConstIterator CBegin() const 
	{ 
		return _start; 
	}
	ConstIterator CEnd() const 
	{ 
		return _finish; 
	}


	void reserve(size_t n)
	{
		//不需要扩容
		if (n <= capacity()) {
			return;
		}
		size_t si = size();
		Iterator tmp = new T[n];
		for (int i = 0; i < si; ++i) {
			*(tmp + i) = *(_start + i);
		}
		delete[] _start;
		_start = tmp;
		_finish = _start + si;
		_endOfStorage = _start + n;
		return;
	}

	void resize(size_t n, const T& val = T())
	{
		reserve(n);
		if (n <= size()) {
			_finish = _start + n;
			return;
		}
		Iterator it = _finish;
		_finish = _start + n;
		while (it ！ = _finish) {
			*it = val;
			it++;
		}
		return;
	}

	//有效容量
	size_t size()const
	{
		return _finish - _start;
	}

	//总容量
	size_t capacity()const
	{
		return _endOfStorage - _start;
	}

	//插入
	bool push_back(const T& val)
	{
		if (_finish == _endOfStorage) {
			reserve(capacity() * 2 + 1);
		}
		*(_finish++) = val;
		return true;
	}

	//删除
	bool pop_back()
	{
		_finish--;
		return true;
	}

	//insert插入
	Iterator insert(Iterator pos, const T& val)
	{
		assert(pos <= _finish);
		//空间不够扩容
		if (_finish == _endOfStorage) {
			size_t si = pos - _start;
			size_t newCapacity = (capacity() == 0) ? 1 : capacity() * 2;
			reserve(newCapacity);
			pos = _start + si;
		}
		Iterator end = _finish - 1;
		while (end >= pos) {
			*(end + 1) = *end;
			end--;
		}
		*pos = val;
		_finish++;
		return pos;
	}

	//erase删除
	Iterator erase(Iterator pos)
	{
		return erase(pos, pos + 1);
	}

	Iterator erase(Iterator begin, Iterator end)
	{
		assert(begin < _finish);
		Iterator s = begin;
		//删除位置在finish后
		if (end >= _finish) {
			_finish = begin;
		}
		else {
			//搬移元素
			Iterator it = end;
			while (it != _finish) {
				*begin = *it;
				begin++;
				it++;
			}
			_finish = begin;
		}
		//返回的始终是删除位置下一个迭代器
		return s;
	}

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

private:
	Iterator _start; // 指向数据块的开始
	Iterator _finish; // 指向有效数据的尾
	Iterator _endOfStorage; // 指向存储容量的尾
};