my_vector

#include <iostream>
#include<vector>
#include<assert.h>
#include<cstring>
using namespace std;

template <class T>
class my_vector
{
public:
	//----------------------------迭代器 iterator-----------------------
	typedef T* iterator;
	typedef const T* const_iterator;
	iterator begin(){return _start;}

	iterator end(){return _finish;}

	const_iterator begin() const { return _start; }

	const_iterator end() const{return _finish;}
	
	//--------------------------构造 my_vector---------------------------
	my_vector() { }

	my_vector(const my_vector& st)
	{
		T* set = new T[st.capacity()];
		_start = set;
		_finish = set;
		_endofstorage = set + st.capacity();
		const_iterator it= st.begin();
		while (it != st.end())
		{
			push_beak(*it);
		}
	}
	
	//------------------------ size_capacity--------------------

	size_t size() const{ return _finish - _start;}

	size_t capacity()  const{ return _endofstorage - _start;}
	
	//-------------------------插入-------------------------------
	void insert(iterator pos, const T& vel)
	{
		assert(pos >= _start);
		assert(pos <= _endofstorage);
		if (_finish == _endofstorage)
		{
			size_t tmp = pos - _start;
			resver(capacity() == 0 ? 4 : capacity() * 2);
			pos = _start + tmp;
		}
		iterator it = _finish;
		while (it >pos )
		{
			*it = *(it - 1);
			it--;
		}
		*it = vel;
		_finish++;
	}

	void push_beak(const T& vel)
	{
		insert(_finish, vel);
	}

	//--------------------------删除-------------------------
	iterator erase(iterator pos)
	{
		assert(pos >= _start);
		assert(pos < _finish);
		
		iterator it = pos+1;
		while (it<_finish)
		{
			*(it - 1) = *it ;
			it++;
		}
		_finish--;

		return pos;
	}

	void pop_back()
	{
		erase(_finish - 1);
	}

	//-----------------------------容量------------------------
	void resver(size_t n)
	{
		if (n > capacity())
		{
			size_t set = size();
			T* old = new T[n];
			for (int i = 0; i < size(); i++)
				old[i] = _start[i];
				//*(old + i) = *(start+i);
			delete[]_start;
			_start = old;

			_finish = _start + set;
			_endofstorage = _start + n;
		}
	}

	void resize(size_t n)
	{ 
		if (n == capacity())
			return;
		if (n > capacity())
		{
			resver(n);
		}
		else
		{
			T* old = new T[n];
			for (int i = 0; i < n; i++)
				old[i] = _start[i];
			//*(old + i) = *(start+i);
			delete[]_start;
			_start = old;

			_finish = _start + n;
			_endofstorage = _start + n;
		}
	}
	//-------------------判断-----------------
	bool empty()
	{
		return _finish == _start;
	}

	//---------------------operator [] < > << >> == =--------------------
	const T& operator [](size_t n) const
	{
		assert(n < size());
		return *(_start + n);
	}
	T& operator [](size_t n)
	{
		assert(n < size());
		return *(_start + n);
	}

	//-----------------析构-------------------------------
	~my_vector()
	{
		delete[]_start;
		_start = _finish = _endofstorage = nullptr;
	}

private:
	iterator _start = nullptr;
	iterator _finish = nullptr;
	iterator _endofstorage = nullptr;


	friend ostream& operator<<(ostream& _cout, const my_vector<T>& d)
	{
		for (size_t i = 0; i < d.size(); ++i) {
			_cout << d[i];
			if (i < d.size() - 1) {
				_cout << " ";
			}
		}
		_cout << endl;
		return _cout;
	}

};