【C++】vector模拟实现

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

/*
inrsert
push_back

pop_back
erase

reserve
capacity()
size()
empty()

begin()
end()

operator[]
*/

namespace liu
{
	template<class T>
		class vector
		{
		public:
			typedef T* iterator;
			typedef const T* const_iterator;

			vector()
				:_start(nullptr)
				,_finish(nullptr)
				,_endofstorage(nullptr)
			{}


			~vector()
			{
				if (_start)
				{
					delete[] _start;
				}
				_start = nullptr;
				_finish = nullptr;
				_endofstorage = nullptr;
			}

			template<class InputIterator>
			vector(InputIterator first, InputIterator last)//迭代器区间初始化
			{
				while (first!=last)
				{
					push_back(*first);
					++first;
				}
			}

			vector(size_t n, const T& val = T())//n个VAL初始化
			{
				reserve(n);//提前开好空间，减少消耗
				for (size_t i=0;i<n;i++)
				{
					push_back(val);
				}
			}

			vector(int n, const T& val = T())
			{
				reserve(n);//提前开好空间，减少消耗
				for (int i = 0; i < n; i++)
				{
					push_back(val);
				}
			}
			//v2(v1)
			vector(const vector<T>& v)//拷贝构造
				:_start(nullptr)
				, _finish(nullptr)
				, _endofstorage(nullptr)
			{
				reserve(v.capacity());
				for (auto& e:v)
				{
					push_back(e);
				}
			}

			vector(initializer_list<T> il)
			{
				reserve(il.size());
				{
					for (auto& e:il)
					{
						push_back(e);
					}
				}
			}

			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;
			}



			iterator begin()
			{
				return _start;
			}

			iterator end()
			{
				return _finish;
			}

			const_iterator begin()const
			{
				return _start;
			}

			const_iterator end()const
			{
				return _finish;
			}

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

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


			void reserve(size_t n)//不仅是内部用，还要提供给外部用
			{
				if (n>capacity())
				{
					size_t oldSize = size();

					T* tmp = new T[n];
					if (_start)
					{
						for (size_t i=0;i<oldSize;i++)
						{
							tmp[i] = _start[i];
						}

						delete[] _start;
					}
					_start = tmp;
					_finish = _start + oldSize;
					_endofstorage = _start + n;
				}
				
			}

			size_t size()
			{
				return _finish - _start;
			}

			size_t capacity()
			{
				return _endofstorage - _start;
			}

			void push_back(const T& x)
			{
				if (_finish==_endofstorage)
				{
					reserve(capacity()==0?4:2*capacity());
				}

				*_finish = x;
				_finish++;
			}

			iterator insert(iterator pos,const T& val)
			{
				assert(pos>=_start&&pos<=_finish);
				if (_finish==_endofstorage)
				{
					size_t len = pos - _start;
					reserve(capacity() == 0 ? 4 : 2 * capacity());
					pos = _start + len;
				}
				iterator i = _finish-1;
				while(i>=pos)
				{
					*(i + 1) = *i;
					i--;
				}
				*pos = val;
				++_finish;
				return pos;//更新迭代器
			}

			iterator erase(iterator pos)
			{
				assert(pos >= _start && pos < _finish);
				iterator i = pos+1;
				while (i<_finish)
				{
					*(i-1) = *i;
					i++;
				}
				--_finish;
				return pos;
			}


			void pop_back()
			{
				assert(!empty());
				_finish--;
			}


			bool empty()
			{
				return _start == _endofstorage;
			}

		private:
			iterator _start;
			iterator _finish;
			iterator _endofstorage;
		};
}