#include <iostream>
using namespace std;
#include <vector>
int main()
{
 int a[] = { 1, 2, 3, 4 };
 vector<int> v(a, a + sizeof(a) / sizeof(int));
 // 使用find查找3所在位置的iterator
 vector<int>::iterator pos = find(v.begin(), v.end(), 3);
 // 删除pos位置的数据，导致pos迭代器失效。
 v.erase(pos);
 cout << *pos << endl; // 此处会导致非法访问
 return 0;
}

erase 删除 pos 位置元素后， pos 位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos 刚好是最后一个元素，删完之后 pos 刚好是 end 的位置，而 end 位置是没有元素的，那么pos 就失效了。因此删除 vector 中任意位置上元素时， vs 就认为该位置迭代器失效了。

2.vector深度剖析及模拟实现

2.1 std::vector的核心框架接口的模拟实现bit::vector

#pragma once
#include<iostream>
#include<assert.h>
namespace xyt
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;
		//默认构造：
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
		{
		}
        vector(const vector<T>& v)
            :_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
        {
            reserve(v.capacity());
            for (auto e : v)
            {
	          push_back(e);
            }
        }
        vector(size_t n,const T& val=T())
            :_start(nullptr)
			, _finish(nullptr)
			, _endofstorage(nullptr)
        {
            resize(n,val);

        }
        void swap(vector<T>& v)
       {
	    std::swap(_start, v._start);
	    std::swap(_finish, v._finish);
	    std::swap(_endofstorage, v._endofstorage);
       }
         vector <T>& operator=(vector<T>v)
       {
	      swap(v);
	     return *this;
       } 
       template<class Inputiterator>
       vector(Inputiterator first, Inputiterator last)
       {
	     while (first != last)
	    {
	     	push_back(*first);
		   ++first;
	    }
       }
		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _endofstorage = nullptr;
			}
		}
		iterator begin()
		{
			return _start;
		}
		iterator end()
		{
			return _finish;
		}
		const_iterator begin()const
		{
			return _start;
		}
		const_iterator end()const
		{
			return _finish;
		}

		//change the capacity of vector
		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t sz = size();
				T* tmp = new T[n];
				if (_start)
				{
					//memcpy(tmp, _start, sizeof(T) * sz);
                    for(size_t i=0;i<v.size(),i++)
                    {
                        _start[i]=v._start[i];
                    }
					delete[] _start;
				}
				_start = tmp;
				_finish = _start + sz;
				_endofstorage = _start + n;
			}
		}
		void push_back(const T& x)
		{
			//扩容
			if (_finish == _endofstorage)
			{
				size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
			}
			*_finish = x;
			_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];
		}
		//指针减法的逻辑是【地址差/单个元素的大小】，算出来的就是元素个数
		size_t capacity()const
		{
			return _endofstorage - _start;
		}
		size_t size()const
		{
			return _finish - _start;
		}
		//在指定位置之后插入数据
		iterator insert(iterator pos, const T& x)
		{
			//检查位置有效性
			assert(pos >= _start && pos <= _finish);
			//如果容器已满
			if (_finish == _endofstorage)
			{
				//为什么要算出pos到start的元素个数len？因为扩容之后迭代器会失效，如果还用之前的pos会导致插入失败
				size_t len = pos - _start;
				size_t sz = capacity(); 
					size_t newcapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newcapacity);
				pos = _start + len;
			}
			iterator end = _finish ;
			while (end > pos)
			{
				*(end) = *(end-1);
				--end;
			}
			*pos = x;
			++_finish;
			return pos;
		}
		//在指定位置之后删除数据
	    iterator erase(iterator pos)
		{
			//检查位置有效性
			assert(pos >= _start && pos < _finish);
			iterator it = pos + 1;
			while (it != _finish)
			{
				*(it - 1) = *it;
				++it;
			}
			--_finish;
			return pos;
		}
		void resize(size_t n,const T&val=T()/*默认构造，注意不能给0，因为vector中储存的不一定是int类型*/)
		{
			//两种情况，第一种n>size,扩容；第二种n<size,缩容
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish != _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}
	private:
		iterator _start;
		iterator _finish;
		iterator _endofstorage;
	};
}