vector

vector的基本概念

vector是表示可变大小数组的序列容器。就像数组一样，vector也采用的连续存储空间来存储元素。也就是意味着可以采用下标对vector的元素进行访问，和数组一样高效。但是又不像数组，它的大小是可以动态改变的，而且它的大小会被容器自动处理。

vector空间的分配

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

capacity，size，reserve，resize

capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2倍增长的。
这个问题经常会考察，不要固化的认为，顺序表增容都是2倍，具体增长多少是根据具体的需求定义
的。vs是PJ版本STL，g++是SGI版本STL。
reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代价缺陷问
题。
resize在开空间的同时还会进行初始化，影响size。

vector迭代器失效问题

插入和删除都会造成迭代器失效，本质上迭代器也是指针在插入删除操作底层发生了改变所以会出现以下几种情况：
删除时，元素向前移动，覆盖了被删除的位置，但是迭代器并没有移动。
插入时可能发生扩容，实际已经使用了新的空间但是迭代器还指向老的空间，老的空间已经释放了。

vector实现的底层

vector里面放了三个指针start，finsh，endofstorage，三个指针分别指向数块的开始，有效数据的结尾，储存容量的尾部。

模仿实现Vector

template <class T>
class Vector {
public:
	typedef T ValueType;
	typedef T* Iterator;
public:
	Iterator Begin() { return _start; }
	Iterator End() { return _finsh; }
	size_t Size() { return _finsh - _start; }
	size_t Capacity() { _endofstorage - _start; }
	void Push_back(const T& x)
	{
		Insret(End(), x);
	}
	void Popback()
	{
		_finsh--;
	}
	Iterator Insret(Iterator pos, const T& x)
	{
		int len = pos - _start;
		if (_finsh == _endofstorage)
		{
			size_t size = Size();
			size_t newCapacity = Capacity() == 0 ? 1 : Capacity() * 2;
			Reserve(newCapacity);
		}
		pos = _start + len;
		for (Iterator i = End(); i > pos; i--)
		{
			_start[i] = _start[i - 1];
		}
		_start[pos] = x;
		_finsh++;
	}
	T& operator[](size_t pos)
	{
		return _start[pos];
	}
	Iterator Erase(Iterator pos)
	{
		Iterator begin = pos + 1;
		while (begin != End())
		{
			*(begin - 1) = *begin;
			begin++;
		}
		_finsh--;
		return pos;
	}
	Vector(Vector& v)
		:_start(nullptr),
		_finsh(nullptr),
		_endofstorage(0)
	{
		Reserve(v.Capacity());
		Iterator it = Begin();
		Iterator itv = v.Begin();
		while (itv != v.End())
		{
			*it = *itv;
			it++;
			itv++;
		}
		_finsh = _start + v.Size();
		_endofstorage = _start + v.Size();
	}
	Vector() :_start(0), _finsh(0), _endofstorage(0)
	{}
	~Vector()
	{
		delete _start;
		_start = _finsh = _endofstorage = nullptr;
	}
	void Reserve(size_t n)
	{
		if (n > Capacity())
		{
			int size = Size();
			T* tmp = new T[n];
			if (_start)
			{
				for (size_t i = 0; i < size; i++)
					tmp[i] = _start[i];
			}
			_start = tmp;
			_finsh = _start + size;
			_endofstorage = _start + n;
		}
	}
	void Rsize(size_t n, const v = T())
	{
		if (n < Capacity())
		{
			_finsh = _start + n;
			return;
		}
		if (n > Capacity())
		{
			Reserve(n);
			Iterator it = End();
			Iterator _finsh = _start + n;
			while (it < _finsh)
			{
				*it = v;
				it++;
			}
		}
	}
	Vector& operator = (Vector v)
	{
		Swap(v);
		return *this;
	}
	void Swap(Vector& v)
	{
		_start = v._start;
		_finsh = v._finsh;
		_endofstorage = v._endofstorage;
	}
private:
	Iterator _start;
	Iterator _finsh;
	Iterator _endofstorage;
};