c++实现vector类，并有一个排序和一个查找的泛型算法

#include<iostream>
#include<cstring>


using namespace std;


template<typename T>
//***********容器类***************
class CVector
{
public:
CVector(int size=10):mpVec(NULL),msize(size),mcur(0)
{
mpVec = new T[msize];
}
~CVector()
{
delete []mpVec;
}
T& operator[](int index)    //重载[]运算符
{
return mpVec[index];
}
const T& operator[](int index)const //const this
{
return mpVec[index];
}
bool IsFull()           
{
return msize == mcur;
}
bool IsEmpty()
{
return mcur == 0;
}
int Length()const        //返回当前容器中数据的长度（个数）     
{
return mcur;
}
void Resize()            //给当前容器重新开辟大小为原来的2倍
{
if(IsFull())
{
T* tmp = new T[2*msize];
memcpy(tmp,mpVec,sizeof(T)*msize);
msize*=2;
delete []mpVec;
mpVec = tmp;
}
}
void PopVec()           
{
if(IsEmpty())
{
return ;
}
mcur--;
}
void PushVec(const T &value)
{
if(IsFull())
{
Resize();
}
mpVec[mcur++] = value;
}
//************容器的迭代器*************
class Iterator
{
public:
typedef T value_type;
Iterator(T *mpVec):iter(mpVec){
}

Iterator(const Iterator &src)
{
iter = src.iter;
}
void operator++()
{
++iter;
}
bool operator!=(const Iterator &src)
{
return iter != src.iter;
}
bool operator==(const Iterator &src)
{
return iter == src.iter;
}
T& operator*()
{
return *iter;
}
bool operator<(const Iterator &src)
{
return iter < src.iter;
}
int operator-(const Iterator &src)
{
return iter-src.iter;
}
Iterator operator-(int length)
{
return Iterator(iter-length);
}
Iterator operator+(int length)
{
return Iterator(iter+length);
}
private:
T *iter;
};


Iterator begin()
{
return Iterator(mpVec);
}
Iterator end()
{
return Iterator(mpVec+mcur);
}


private:
T *mpVec;     //容器中数据的类型指针   
int msize;    //容器所能包含的数据个数
int mcur;     //当前容器中数据的个数


CVector(const CVector<T>&);
CVector<T>& operator=(const CVector<T>&);
};


template<typename Iterator>
//****************通过迭代器给容器中的数据排序**************
void Mysort(Iterator first,Iterator last)
{
Iterator i = first;
Iterator j = first;
int k = 0;

Iterator::value_type tmp;
for(;i<last-1;++k,++i)
{
for(j=first;j<last-1-k;++j)
{
if(*j > *(j+1))
{
tmp = *j;
*j = *(j+1);
*(j+1) = tmp;
}
}
}
}


template<typename Iterator,typename T>
//******************查找容器中和value值相等的下标**************
Iterator MFind(Iterator first,Iterator last,const T &value)
{
Iterator i = first;
for(;i != last;++i)
{
if(value == *i)
{
cout<<"could find"<<endl;
return i;
}
}


cout<<"can not find"<<endl;
return last;
}


int main()
{
CVector<int> A(20);
for(int i=0;i<20;i++)
{
A.PushVec(rand()%100+1);
}


int size = A.Length();
for(int j=0;j<20;j++)
{
cout<<A[j]<<" ";
}
cout<<endl;

MFind(A.begin(),A.end(),2);
//Mysort(A.begin(),A.end());


//CVector<int>::Iterator tmp = A.begin();
//for(;tmp != A.end();++tmp)
//{
// cout<<*tmp<<" ";
//}


return 0;
}