注意几点：

分配内存不要使用new和delete，因为new的同时就把对象构造了，而我们需要的是原始内存。所以应该使用标准库提供的allocator类来实现内存的控制。当然也可以重载operator new操作符，因为二者都是使用malloc作为底层实现，所以直接采用malloc也可以。

对象的复制必须使用系统提供的uninitialized_fill和uninitialized_copy，因为我们无法手工调用构造函数。

对于C++中的对象，除了POD之外，使用memcpy系列的函数是绝对错误的。

myvector.h

#ifndef _VECTOR_H_
#define _VECTOR_H_
#include
#include
#include

template
class Vector
{
public:
typedef T *iterator;
typedef const T *const_iterator;
typedef size_t size_type;
typedef T value_type;

class reverse_iterator
{
public:
reverse_iterator(iterator it = NULL):current_(it) {}
iterator base() const { return current_; }

reverse_iterator &operator++()//前置
{
--current_;
return *this;
}

reverse_iterator operator++(int)//后置
{
reverse_iterator temp(*this);
--current_;
return temp;
}

reverse_iterator &operator--()
{
++current_;
return *this;
}

reverse_iterator operator--(int)
{
reverse_iterator temp(*this);
++current_;
return temp;
}

T &operator*()
{
iterator temp = current_;
return *--temp;
}

T *operator->()
{
iterator temp = current_;
return --temp;
}

friend bool operator==(const reverse_iterator &lhs,
const reverse_iterator &rhs)
{
return lhs.current_ == rhs.current_;
}
friend bool operator!=(const reverse_iterator &lhs,
const reverse_iterator &rhs)
{
return lhs.current_ != rhs.current_;
}
private:
iterator current_;
};

Vector() { create(); }//无参构造函数
explicit Vector(size_type n, const T &t = T()) { create(n, t); }
Vector(const Vector &v) { create(v.begin(), v.end());}// 拷贝构造函数
~Vector() { uncreate();}

Vector &operator=(const Vector &other);
T &operator[] (size_type i) { return data_[i]; }
const T &operator[] (size_type i) const {return data_[i]; }

void push_back(const T &t);

size_type size() const { return avail_ - data_;}
size_type capacity()const { return limit_ - data_;}

iterator begin() { return data_; }
const_iterator begin() const {return data_;}
iterator end() {return avail_;}
const_iterator end() const { return avail_; }

reverse_iterator rbegin(){return reverse_iterator(end());}
reverse_iterator rend() {return reverse_iterator(begin());}

void swap(Vector &rhs)
{
std::swap(data_, rhs.data_);
std::swap(avail_, rhs.avail_);
std::swap(limit_, rhs.limit_);
}
private:
iterator data_;//首元素
iterator avail_;//末尾元素的下一个
iterator limit_;

std::allocator alloc_;//内存分配器

void create();
void create(size_type, const T &);
void create(const_iterator, const_iterator);

void uncreate();

void grow();
void uncheckAppend(const T &);
};

template
inline Vector &Vector::operator=(const Vector &rhs)
{
if(this != rhs)
{
uncreate();//释放原来的内存
create(rhs.begin(), rhs.end());
}
return *this;
}

template
inline void Vector::push_back(const T &t)
{
if(avail_ == limit_)
{
grow();
}
uncheckAppend(t);
}