简单重写容器vector

 #pragma once
 #include <iostream>
 using namespace std;

 template<class T>
 class CMyVector
 {
 public:
     CMyVector() { buff = NULL; len = maxSize = ; }
     ~CMyVector() { _clear(); }
     size_t capacity();
     size_t size();
     bool empty();
     void print();
     //迭代器
     struct MyIterator
     {
         T* pt;
         MyIterator() { pt = NULL; }
         MyIterator(MyIterator& it) { pt = it.pt; }
         ~MyIterator() { pt = NULL; }
         MyIterator operator=(const MyIterator& it) {
             pt = it.pt;
             return *this;
         }
         bool operator!=(const MyIterator& it) {
             return (pt != it.pt);
         }
         T operator*() {
             return (*pt);
         }
         MyIterator& operator++() {
             ++pt;
             return *this;
         }
         MyIterator operator++(int) {
             MyIterator tmp = *this;
             ++pt;
             return tmp;
         }
         MyIterator operator+(int n)const {
             MyIterator tmp;
             tmp.pt = pt + n;
             return tmp;
         }
         int operator-(const MyIterator& it)const {
             return (pt - it.pt);
         }
         MyIterator operator-(int n) {
             MyIterator tmp;
             tmp.pt = pt - n;
             return tmp;
         };
     };

     MyIterator begin()
     {
         MyIterator tmp;
         tmp.pt = buff + ;
         return tmp;
     }
     MyIterator end()
     {
         MyIterator tmp;
         tmp.pt = buff + len;
         return tmp;
     }

     T operator[](size_t pos) {
         return *(buff + pos);
     }

     void push_back(T t);
     void insert(const MyIterator& it, T t);
     void insert(const MyIterator& it, const MyIterator& first, const MyIterator& last);
     void assign(const MyIterator& first, const MyIterator& last);
     T at(size_t pos);
 private:
     T* buff;
     size_t len;
     size_t maxSize;

     void _clear();
 };

 template<class T>
 void CMyVector<T>::push_back(T t)
 {
     if (len >= maxSize)
     {
         maxSize += ((maxSize >> ) > ) ? (maxSize >> ) : ;
         T* tmp = new T[maxSize];
         if (buff)
         {
             memcpy(tmp, buff, sizeof(T)*len);
             delete[] buff;
         }
         buff = tmp;
     }
     buff[len++] = t;
 }

 template<class T>
 void CMyVector<T>::insert(const MyIterator& it, T t)
 {
     int pos = it - begin();
     if (pos > (int)len)
         return;

     if (len >= maxSize)
         maxSize += ((maxSize >> ) > ) ? (maxSize >> ) : ;

     T* tmp = new T[maxSize];
     if (buff) {
         memcpy(tmp, buff, sizeof(T)*pos);
         tmp[pos] = t;
         memcpy(tmp + pos + , buff + pos, sizeof(T)*(len - pos));
         delete[] buff;
     }
     else
         tmp[pos] = t;
     buff = tmp;
     ++len;
 }

 template<class T>
 void CMyVector<T>::insert(const MyIterator& it, const MyIterator& first, const MyIterator& last)
 {
     int pos = it - begin();
     if (pos > (int)len)
         return;

     int count = ;
     if ((count = last - first) <= )
         return;

     while ((len + count) >= maxSize)
         maxSize += ((maxSize >> ) > ) ? (maxSize >> ) : ;

     T* tmp = new T[maxSize];
     if (buff) {
         memcpy(tmp, buff, sizeof(T)*pos);
         for (int i = ; i < count; ++i)
             tmp[pos + i] = *(first + i);

         memcpy(tmp + pos + count, buff + pos, sizeof(T)*(len - pos));
         delete[] buff;
     }
     else
         for (int i = ; i < count; ++i)
             tmp[pos + i] = *(first + i);

     buff = tmp;
     len += count;

 }

 template<class T>
 void CMyVector<T>::assign(const MyIterator& first, const MyIterator& last)
 {
     _clear();
     insert(begin(), first, last);
 }

 template<class T>
 T CMyVector<T>::at(size_t pos)
 {
     return *(buff + pos);
 }

 template<class T>
 void CMyVector<T>::_clear()
 {
     if (buff)
         delete[] buff;

     buff = NULL;
     len = maxSize = ;
 }

 template<class T>
 size_t CMyVector<T>::capacity()
 {
     return maxSize;
 }

 template<class T>
 size_t CMyVector<T>::size()
 {
     return len;
 }

 template<class T>
 bool CMyVector<T>::empty()
 {
     return (len == );
 }

 template<class T>
 void CMyVector<T>::print()
 {
     /*CMyVector<T>::MyIterator it;
     it = begin();
     while(it != end())
     cout << *it++ << " ";*/
     for (auto it = begin(); it != end(); ++it)
     {
         cout << *it << " ";
     }
     cout << endl;
 }