Vector

#include <iostream>

template<typename T>
class Vector;
template<typename T>
class Iterator
{
public:
	typedef Iterator<T> MyIt;
	Iterator (Vector<T>* pv,int idx):
		pvec(pv),index(idx)
	{}
	bool operator!=(const MyIt _Right)
	{
		return index!=_Right.index;
	}
	MyIt& operator++()
	{
		index++;
		return *this;
	}
	const MyIt operator++(int)
	{
		const MyIt tmp(*this);
		index++;
		return tmp;
	}
	MyIt& operator--()
	{
		index--;
		return *this;
	}
	const MyIt operator--(int)
	{
		const MyIt tmp(*this);
		index--;
		return tmp;
	}
	const MyIt operator+(int dis)
	{
		MyIt tmp(*this);
		tmp.index+=dis;
		return tmp;
	}
	const MyIt operator-(int dis)
	{
		MyIt tmp(*this);
		tmp.index-=dis;
		return tmp;
	}

	bool operator<(MyIt _Right)
	{
		return index < _Right.index;
	}
	T& operator*();
	const T operator*()const;
private:
	Vector<T>* pvec;
	int index;
};

template<typename T>
class Vector
{
public:
	typedef Iterator<T> iterator;
	Vector()
	{
		parr=new T[1]();
		cur=0;
		total=1;
	}
	Vector(int size)
	{
		parr=new T[size]();
		cur=total=size;
	}
	Vector(int size,T val)
	{
		parr=new T[size];
		for(int i=0;i<size;i++)
		{
			parr[i]=val;
		}
		cur=total=size;
	}
	~Vector()
	{
		delete[]parr;
		parr=NULL;
	}
	iterator begin()
	{
		return iterator(this,0);
	}
	iterator end()
	{
		return iterator(this,cur);
	}
	void insert(iterator _where,T val)
	{
		if(full())
		{
			resize(total*2);
		}
		for (iterator it=end(); it!=_where;it--)
		{
			*it=*(it-1);
		}
		*_where=val;
		cur++;
	}
	void resize(size_t size)
	{
		T* mptr=new T[size];
		memcpy(mptr,parr,sizeof(T)*total);
		delete[] parr;
		parr=mptr;
		total*=2;
	}
	void push_back(int val)
	{
		insert(end(),val);
	}
	void pop_back()
	{
		erase(end()-1);
	}
	void erase(iterator _where)
	{
		if(empty())
		{
			throw std::exception("vector is empty!");
		}
		for(iterator it=_where;it<end()-1;it++)
		{
			*it=*(it+1);
		}
		cur--;
	}
	T& operator[](int index)
	{
		return parr[index];
	}
	bool empty()
	{
		return cur==0;
	}
private:
	bool full()
	{
		return cur==total;
	}
	T* parr;
	int cur;
	int total;
};
template<typename T>
T& Iterator<T>::operator*()
{
	return (*pvec)[index];
}
template<typename T>
const T Iterator<T>::operator*()const
{
	return (*pvec)[index];
}
int main()
{
	Vector<int> vec;
	Vector<int> vec1(10);//size  
	Vector<int> vec2(10, 20);//size  value

	for (int i = 0; i < 10; i++)
	{
		vec.push_back(i + 1);
	}
	//1  - 10
	vec.insert(vec.begin(), 20);// 20  1 - 10
	vec.erase(vec.end() - 3); //20  1-7 9 10
	vec.pop_back(); //20  1-7 9

	Vector<int>::iterator it = vec.begin();
	while (it != vec.end())
	{
		std::cout << *it << " ";
		it++;
	}
	std::cout << std::endl;
	return 0;
}