【C++】vector模拟实现

实现以下功能：

1. 构造函数：a.无参默认构造 b.n个val构造 c.迭代器区间构造 d.initializer_list构造，类似于数组 e.拷贝构造

2. =赋值重载

3. 重载

4. 实现reserve接口

5. 实现size()，capacity()接口

6. 实现push_bakc接口，尾插

7. 实现insert接口，位置插入

8. 实现erase接口，位置删除

9. 实现pop_back接口，尾删

10. 实现empty接口，判断容器是否为空

11. 实现迭代器

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

    /*
    inrsert
    push_back

    pop_back
    erase

    reserve
    capacity()
    size()
    empty()

    begin()
    end()

    operator[]
    */

    namespace liu
    {
    template
    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;
    	};

    }