c++实现一个简易vector加强版

template<typename T>或者template<class T>均可

class Name_Of_Class
{
// ......
};

Name_Of_Class<T>::Name_Of_Class()
{
//......
}

Name_Of_Class<T>::Name_Of_Class(const  Name_Of_Class<T>&  the_object)
{
//......
}

using std::cin;
using std::cout;
using std::istream;
using std::ostream;
using std::endl;

template<typename T>
class VectorT
{
public:
bool operator =(const VectorT<T>&);
friend bool operator ==(const VectorT<T>&,const VectorT<T>&);

int capasity();
int size();
bool push_back(T);
bool pop_back();

bool reserve(int);
bool resize(int);
bool empty();
T value_at(int);
void change_value_at(int,T);
void traval();

VectorT();
VectorT(int);
VectorT(VectorT<T>&);
~VectorT();

private:
bool full();
T *p;
int count;
int max_count;
};
template<typename T>
void VectorT<T>::traval()
{
for(int i=0;i<count;i++)
{
cout<<p[i]<<" ";
}
cout<<endl;
}
template<typename T>
bool VectorT<T>::operator =(const VectorT<T>& temp)
{
if(max_count>=temp.count)
{
count=temp.count;
max_count=temp.max_count;
p=new T[max_count];
for(int i=0;i<temp.count;i++)
p[i]=temp.p[i];
}
else
{
delete [] p;
p=new T[temp.count];
for(int i=0;i<temp.count;i++)
p[i]=temp.p[i];
}
return true;
}
template<typename T>
bool operator ==(const VectorT<T>& data1,const VectorT<T>& data2)
{
bool flag=true;
if(data1.count!=data2.count && flag==true)
flag=false;
if(flag==true)
{
for(int i=0;i<data1.count;i++)
{
if(data1.p[i]!=data2.p[i])
{
flag=false;
break;
}
}
}
return flag;
}
/*******************************************/
template<typename T>
VectorT<T>::VectorT()
{
p=new T[50];
count=0;
max_count=50;
}
template<typename T>
VectorT<T>::VectorT(int length)
{
p=new T[length];
count=0;
max_count=length;
}
template<typename T>
VectorT<T>::VectorT(VectorT<T>& temp)
{
count=temp.count;
max_count=temp.max_count;
p=new T[max_count];
for(int i=0;i<temp.count;i++)
p[i]=temp.p[i];
}
/*******************************************/
template<typename T>
VectorT<T>::~VectorT()
{
delete [] p;
}
/*******************************************/
template<typename T>
bool VectorT<T>::full()
{
if(count==max_count)
return true;
else
return false;
}
template<typename T>
bool VectorT<T>::empty()
{
if(count==0)
return true;
else
return false;
}

/*******************************************/
template<typename T>
int VectorT<T>::capasity()
{
return max_count;
}
template<typename T>
int VectorT<T>::size()
{
return count;
}
/*******************************************/
template<typename T>
bool VectorT<T>::reserve(int length)
{
if(length<=max_count)
return false;

T *temp;
temp=new T[max_count];
for(int i=0;i<count;i++)
{
temp[i]=p[i];
}
delete [] p;

max_count=length;
p=new T[max_count];
for(i=0;i<count;i++)
{
p[i]=temp[i];
}
delete [] temp;

return true;
}
template<typename T>
bool VectorT<T>::resize(int length)
{
if(length<=max_count)
{
count=length;
}
else if(length>max_count)
{
count=length;
reserve(length);
}
return true;
}
template<typename T>
bool VectorT<T>::push_back(T data)
{

if(full())
{
reserve(max_count*2);
p[count++]=data;
}
else
{
p[count++]=data;
}

return true;
}
template<typename T>
bool VectorT<T>::pop_back()
{
if(empty())
{
cout<<"VectorT Empty"<<endl;
exit(1);
}
else
{
count--;
}
return true;
}

/*******************************************/
template<typename T>
T VectorT<T>::value_at(int i)
{
if(i>=count)
{
cout<<"Error location"<<endl;
return -1;
}
return p[i];
}
template<typename T>
void VectorT<T>::change_value_at(int i,T data)
{
if(i>=count)
{
cout<<"Error location"<<endl;
}
p[i]=data;
}
/*******************************************/