【数据结构】模拟实现Vecotr

namespace my_vector
{

	template 
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;//常量指针，指针指向的值不可以变；
        
		//构造函数
		vector()
			:start(nullptr)
			,finish(nullptr)
			,end_of_storage(nullptr)
		{
		    

		}
		//析构函数
		~vector()
		{
			delete[] start;
			start = finish = end_of_storage = nullptr;	
		}

		

		//const T& x=T();   这个的生命周期从一行被延长为当前作用域结束；无论是内置类型还是自定义类型都可以采用匿名形式
		vector(int n,const T& val=T())
			:start(nullptr)
			, finish(nullptr)
			, end_of_storage(nullptr)
		{
		
			for (int i=0;i
		vector(InputIterator first,InputIterator last)
		{
			while (first!=last)
			{
				//vs库里面的迭代器不是原生指针，而是被封装好的类；
				push_back(*first);//这里不能用自定义类型会出现“非法寻址”的问题
				++first;
			}
		 
		}

		//拷贝构造函数
		vector(const vector& v)
		{
			reserve(v.capacity());
			//浅拷贝：memcpy(start,v.start,sizeof(t)*v.size());
			
			//深拷贝
			for(int i=0;i）属于深拷贝；
			}
			finish = start + v.size();
			end_of_storage = start + v.capacity();
		}

		vector(initializer_list i1)
		{
			//常量数组结构体对象
			initializer_list ::iterator it = i1.begin();
			while (it!=i1.end())
			{
				push_back(*it);
				++it;
			}
		
		}

		void swap(vector& v)
		{
			std::swap(start,v.start);
			std::swap(finish, v.finish);
			std::swap(end_of_storage, v.end_of_storage);		
		}

		vector& operator=(vector v)
		{
			swap(v);
			return *this;
		}

		void reserve(size_t n)  
		{
			//需要的空间大于原容量才进行扩容
			if (n > capacity())
			{
				T* tmp = new T[n];
				size_t sz = size();
				if (start)//如果原来的空间不为空，那么就直接拷贝原来所有的元素（如果是自定义类型，会两次析构）；
				{
					//memcpy(tmp,start,sizeof(T)*size());
					for (int i=0;icapacity())
			{
				reserve(n);
				while (finish!=end_of_storage)
				{
					*finish = val;
					++finish;
				}

			}
			else
			{

				if (n < size())
				{
					//删除数据
					finish = start + n;
				}

			}
		}

		//迭代器失效问题：野指针（扩容引起）
		iterator insert(iterator pos,const T& val)
		{
			assert(pos<=finish);
			assert(pos>=start);

			
			//判断是否需要扩容
			if (finish==end_of_storage)
			{    
				int len = pos - start;
				size_t newCapacity = capacity() == 0 ? 4 : capacity() * 2;
				reserve(newCapacity);
				//扩容会导致pos迭代器失效，需要更新一下；
				pos = start + len;
			}

			iterator end = finish - 1;
			while (end>=pos)
			{
				*(end+1) = *end;
				--end;
			}
			*pos = val;
			++finish;
			return pos;//返回更改后的形参pos，让pos指向插入的元素，也就是原来指向的前一个；
		}


		iterator erase(iterator pos)
		{
			assert(pos = start);
            
			iterator end = pos+1;
     		while (end