自定义vector,还有几个函数没写(懒得写了)

#include<iostream>
using namespace std;
template<class T>
class MyVector
{
public:
struct Myiteration//迭代器结构体
{
T* It;
Myiteration()//初始化
{
It = NULL; 
}
Myiteration(const Myiteration& hh)//初始化
{
It = hh.It;
}
~Myiteration(){}//析构函数
Myiteration &operator=(const Myiteration& TT)//重载=迭代器
{
It = TT.It;
return *this;
}
Myiteration &operator=(T* TT)//重载=T*
{
It = TT;
return *this;
}
Myiteration &operator++()//重载前置++
{
It++;
return *this;
}
Myiteration operator+(int i)//重载+
{
Myiteration rr(*this);
rr.It+=i;
return rr;
}
Myiteration operator-(int i)//重载-
{
Myiteration rr(*this);
rr.It -= i;
return rr;
}
int operator-(Myiteration& aa)//重载-
{
return It-aa.It;
}
Myiteration operator++(T)//重载++后置
{
Myiteration SS = *this;
It++;
return SS;
}
Myiteration &operator--()//重载前置--
{
It--;
return *this;
}
Myiteration operator--(T)//重载--后置
{
Myiteration SS = *this;
It--;
return SS;
}
bool operator!=(const Myiteration tt)//重载!=
{
return It!=tt.It;
}
bool operator==(const Myiteration tt)//重载==
{
return It == tt.It;
}
bool operator<(const Myiteration tt)//重载<
{
return It < tt.It;
}
bool operator>(const Myiteration tt)//重载>
{
return It > tt.It;
}
bool operator<=(const Myiteration tt)//重载<=
{
return It <= tt.It;
}
bool operator>=(const Myiteration tt)//重载>=
{
return It >= tt.It;
}
T &operator*()
{
return*It ;
}

};

Myiteration begin()
{
return start;
}
Myiteration end()
{
return close;
}
MyVector();//构造函数
MyVector(const MyVector<T>&a);//拷贝构造函数
MyVector(unsigned size);//构造容量为size的且默认初始化函数
MyVector(unsigned size,const T& emm);//构造容量为size并初始化为emm的函数
~MyVector();//析构函数
const T&operator[](unsigned i);//重载[]
MyVector &operator=(const MyVector &aa);//向量之间的copy
void clear();//清除所有数据
void erase(Myiteration position);//删除指定位置上的元素
void erase(Myiteration position, Myiteration position1);//删除指定位置position到position1区间上的元素
void push_back(T emm);//尾插一个数据
void assign(Myiteration beg, Myiteration end);//将区间内的数据copy给对象
void assign(unsigned n, T ennm);//将n个ennm copy给对象
unsigned capacity()//返回数据个数
{
return Len;
}
const T &back()//返回最后一个数据
{
return V[Len];
}
bool empty()//判断是否为空
{
return Len == 0;
}
unsigned size()//返回实际数据的个数
{
return Len;
}
void pop_back();//删除最后的数据
friend void swap(MyVector &a, MyVector &b)//交换两个向量
{
T* p = new T[a.Len > b.Len ? a.Len : b.Len];
unsigned Temp = a.Len;
for (unsigned i = 0; i < a.Len; ++i)
p[i] = a.V[i];
delete[]a.V;
a.V = new T[b.Len];
for (unsigned i = 0; i < b.Len; ++i)
a.V[i] = b.V[i];
a.Len = b.Len;
a.MaxSize = b.Len;
a.start = a.V;
a.close = a.start + a.Len;
delete[]b.V;
b.V = new T[Temp];
for (unsigned i = 0; i < Temp; ++i)
b.V[i] = p[i];
delete[]p;
b.Len = Temp;
b.MaxSize = Temp;
b.start = b.V;
b.close = b.start+Temp;
}
//void  swap(MyVector<T>&a);//交换两个向量
protected:
T* V;
unsigned MaxSize;//容量大小
unsigned Len;//长度
Myiteration start;
Myiteration close;
};
template <typename T>
void  MyVector<T>::pop_back()//删除最后的数据
{
if (V)
{
if (Len > MaxSize * 2 / 3)
{
Len--;
close--;
}
else
{
T* Y = new T[MaxSize = Len];
for (unsigned i = 0; i < Len; ++i)
Y[i] = V[i];
delete[]V;
if (Len)
{
V = Y;
start = V;
close = V + Len;
}
}
}
}
template <typename T>
void MyVector<T>::push_back(T emm)//尾插一个数据
{
if (Len>=MaxSize)
{
if (!V)
{
V = new T[1];
V[Len++] = emm;
MaxSize = 1;
start = V;
close = V + Len;
}
else
{
T* Y = new T[MaxSize = ((MaxSize / 2) < 1 ? 1 : MaxSize / 2) + MaxSize];
for (unsigned i = 0; i < Len; ++i)
Y[i] = V[i];
delete[]V;
Y[Len++] = emm;
start = Y;
close = Y + Len;
V = Y;
}
}
else
{
V[Len++] = emm;
start = V;
close = V + Len;
}
}
template <typename T>
void MyVector<T>::assign(Myiteration beg, Myiteration end)//将区间内的数据copy给对象
{
if (V)
{
delete[]V;
V = NULL;
}
V = new T[(end - beg)+1];
for (unsigned i = 0; i<(end - beg) + 1; ++i)
{
V[i] = *(beg+i);
}

MaxSize = Len = end - beg + 1;
start = V;
close = V + Len;
}
template <typename T>
void MyVector<T>::assign(unsigned n, T ennm)//将n个ennm copy给对象
{
if (V)
{
delete[]V;
V = NULL;
}
V = new T[n];
for (unsigned i = 0; i <n; ++i)
V[i] = ennm;
MaxSize = Len = n;
start = V;
close = V + Len;
}
template <typename T>
void MyVector<T>::erase(Myiteration  ps)//删除指定位置上的元素
{
if (Len > MaxSize * 2 / 3)
{
if (V&&ps >= begin() && ps <end())
{
for (Myiteration gg = ps; gg != end(); gg++)
{
*gg = *(gg + 1);
}
}
Len--;
close = V + Len;
}
else if(Len)
{
T* Y = new T[MaxSize = Len];
for (unsigned i = 0; i < Len; ++i)
Y[i] = V[i];
delete[]V;
if (Len)
{
V = Y;
start = V;
close = V + Len;
}
}
else if (!Len)
{
V = NULL;
MaxSize = 0;
start = close = V;
}


}
template <typename T>
void MyVector<T>::erase(Myiteration  ps, Myiteration  ps1)//删除指定ps到ps1区间内位置上的元素
{
if (Len>(unsigned)(ps1 - ps + 1))
{
if (V&&ps >= begin() && ps < end() && ps1 >= begin() && ps1 < end())
{
for (ps1; ps1 != end(); ps1++)
{
*ps = *(ps1+1);
ps++;
}
}
Len=Len-(ps1-ps+1);
close = V + Len;
if (Len < MaxSize * 2 / 3)
{
T* Y = new T[MaxSize = Len];
for (unsigned i = 0; i < Len; ++i)
Y[i] = V[i];
delete[]V;
V = Y;
start = V;
close = V + Len;
}
}
else if (Len == (ps1 - ps + 1))
{
delete[]V;
V = NULL;
MaxSize = 0;
Len = 0;
start = close = V;
}


}
template <typename T>
void MyVector<T>::clear()//清除所有数据
{
if (V)
{
delete[]V;
V = NULL;
MaxSize = 0;
Len = 0;
start = close = V;
}
}
template <typename T>
MyVector<T> &MyVector<T>::operator = (const MyVector<T> &aa)//向量之间的copy
{
if (V)
delete[]V;
V = new T[aa.MaxSize];
for (unsigned int i = 0; i < aa.MaxSize; ++i)
V[i] = aa.V[i];
MaxSize = aa.MaxSize;
Len = aa.Len;
start = V;
close = V + Len;
return *this;
}
template <typename T>
const T& MyVector<T>::operator[](unsigned i)
{
return V[i];
}
template <typename T>
MyVector<T>::MyVector()
{
    V = NULL;
MaxSize = 0;
Len = 0;
close = start = V;
}
template <typename T>
MyVector<T>::MyVector(const MyVector<T>&a)//拷贝构造函数
{
V = new T[a.MaxSize];
memcpy(V, a.V, a.Len);
MaxSize = a.MaxSize;
Len = a.Len;
start = V;
close = V + Len;
}
template <typename T>
MyVector<T>::MyVector(unsigned size)//构造容量为size的且默认初始化函数
{
V = new T[size];
memset(V, 0, size);
MaxSize = size;
Len = 0;
start = V;
close = V + Len;
}
template <typename T>
MyVector<T>::MyVector(unsigned size, const T& emm)//构造容量为size并初始化为emm的函数
{
V = new T[size];
MaxSize = size;
Len = size;
for (unsigned int i = 0; i < size; ++i){V[i] = emm;}
start = V;
close = V + Len;
}
template <typename T>
MyVector<T>::~MyVector()
{
if (V)
delete[]V;
}