自己实现的Vector类 这是Vector.h文件

#ifndef  MYVECTOR_H
#define MYVECTOR_H
#include <memory>
#include <cstddef>
using namespace std;


template <class T>class Vector
{
public:
Vector():elements(0),first_free(0),end(0){}
void push_back(const T& t);
void reserve(const size_t capa);
//调整Vector的大小，使其能容纳n个元素；
//如果n小于vector当前大小，则删除多余元素；
//否则。添加采用值初始化新元素；
void resize(const size_t n);
void resize(const size_t n,const T& t);
T& operator[](const size_t index);
const T& operator[](const size_t index)const;
typedef T* iterator;
iterator begin()
{
return elements;
}
iterator End()
{
return first_free;
}
size_t size()
{
return first_free-elements;
}
size_t capacity()
{
retun end-elements;
}
private:
static allocator<T> alloc;
void reallocate();
T* elements;
T* first_free;
T* end;
};
template <class T> allocator<T> Vector<T>::alloc;


template <class T> void Vector<T>::push_back(const T& t)
{
if (first_free==end)
reallocate();
alloc.construct(first_free,t);
++first_free;
}
template <class T> void Vector<T>::reallocate()
{
ptrdiff_t size = first_free-elements;
ptrdiff_t newcapacity = 2*max(size,1);
//分配空间以保存newcapacity个T类型的元素
T* newelements = alloc.allocate(newcapacity);
//在新空间中构造现有元素的副本
uninitialized_copy(elements,first_free,newelements);
//逆序撤销旧元素，调用*p的析构函数
for (T *p = first_free;p!=elements;)
{
alloc.destroy(--p);
}
//不能用0值指针调用deallocate
if (elements)
{
alloc.deallocate(elements,end-elements);
}
//数据结构指向新元素
elements = newelements;
first_free = newelements+size;
end = elements+newcapacity;
}
template <class T>
void Vector<T>::reserve(const size_t capa)
{
size_t size = first_free-elements;
T* newelements = alloc.allocate(capa);
if (size<=capa)
{
uninitialized_copy(elements,first_free,newelements);
}else
{
uninitialized_copy(elements,elements+capa,newelements);
}
for (T *p=first_free;p!=elements;)
{
alloc.destroy(--p);
}
if (elements)
{
alloc.deallocate(elements,end-elements);
}
elements = newelements;
first_free = elements+size;
end = elements+capa;
}
template <class T> void Vector<T>::resize(const size_t n)
{
size_t = first_free-elements;
size_t capacity = end-elements;
if(n>capacity)
{
reallocate();//获取更多空间并复制现有元素
//添加采用值初始化的元素
uninitialized_fill(elements+size,elements+n,T());
}else if(n>size)
{
uninitialized_fill(elements+size,elements+n,T())
}else
{
for (T *p = first_free;p!=elements+n;)
{
alloc.destroy(--p);
}
first_free = elements+n;
}
}
template <class T> void Vector<T>::resize(const size_t n,const T& t)
{
size_t size = first_free-elements;
size_t capacity = end-elements;
if (n>capacity)
{
reallocate();
uninitialized_fill(elements+size,elements+n,t);
}else if (n>size)
{
uninitialized_fill(elements+size,elements+n,t);
}else
{
for (T *p = first_free;p!=elements+n;)
{
alloc.destroy(p);
}
}
first_free = elements+n;
}
template<typename T> T& Vector<T>::operator[](const size_t index)
{
return elements[index];
}
template<typename T>const T& Vector<T>::operator[](const size_t index)const
{
return elements[index];
}

#endif

第二种方法

#ifndef MYVECTOR_H
#define MYVECTOR_H
#include <memory>
#include <cstddef>
using namespace std;
template<class T>class Vector
{
public:
Vector():elements(0),first_free(0),end(0){}
void push_back(const T& t);
void reserve(const size_t capa);
void resize(const size_t n);
const void resize(const size_t n,const T& t)const;
T& operator[](const size_t);
const T& operator[](const size_t)const;
size_t size()
{
return first_free-elements;
}
size_t capacity()
{
return end - elements;
}


private:
static std::allocator<T> alloc;
void reallocate();
T* elements;
T* first_free;
T* end;


};
template<class T> std::allocator<T> Vector<T>::alloc;
template<class T> void Vector<T>::push_back(const T& t)
{
if (first_free==end)
reallocate();
new(first_free)T(t);
++first_free;
}
template<class T> void Vector<T>::reallocate()
{
ptrdiff_t size = first_free-elements;
ptrdiff_t newcapacity = 2*max(size,1);
T* newelement = static_cast<T*> (operator new[](newcapacity*sizeof(T)));
uninitialized_copy(elements,first_free,newelement);
for (T *p = first_free;p != elements;)
{
(--p)->~T();
}
if (elements)
{
operator delete[](elements);
}
elements = newelement;
first_free = elements+size;
end = elements+newcapacity;


}template <class T> void Vector<T>::reserve(const size_t capa)
{
size_t size = first_free-elements;
T* newelements = static_cast<T*>(operator new[](capa*sizeof(T)));


if (size<capa)
{
uninitialized_copy(elements,first_free,newelements);
}else
{
uninitialized_copy(elements,elements+capa,newelements);
}
for (T *p = first_free;p!=elements;)
{
(--p)->~T();
}
if (elements)
{
operator delete[](elements);
}
elements = newelements;
first_free = elements+min(size,capa);
end = elements+capa ;
}
template<class T> void Vector<T>::resize(const size_t n)
{
size_t size = first_free-elements;
size_t capacity = end - elements;
if (n>capacity)
{
reallocate();
uninitialized_fill(elements+size,elements+n,T());
}else if (n>size)
{
uninitialized_fill(elements+size,elements+n,T());
}else
for (T *p = first_free;p !=elements+n;)
{
(--p)->~T();
}
first_free = elements+n;
}
template<class T> const void Vector<T>::resize(const size_t n,const T& t)const
{
size_t size = first_free-elements;
size_t capacity = end - elements;
if (n>capacity)
{
reallocate();
uninitialized_fill(elements+size,elements+n,t);
}else if (n>size)
{
uninitialized_fill(elements+size,elements+n,t);
}else
for (T *p = first_free;p !=elements+n;)
{
(--p)->~T();
}
first_free = elements+n;
}
template<class T> T& Vector<T>::operator[](const size_t index)
{
return elements[index];
}
template<class T> const T& Vector<T>::operator[](const size_t index)const


{
return elements[index];
}
#endif