简单重写容器vector

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

template<class T>
class CMyVector
{
public:
    CMyVector() { buff = NULL; len = maxSize = 0; }
    ~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 + 0;
        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 >> 1) > 1) ? (maxSize >> 1) : 1;
        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 >> 1) > 1) ? (maxSize >> 1) : 1;


    T* tmp = new T[maxSize];
    if (buff) {
        memcpy(tmp, buff, sizeof(T)*pos);
        tmp[pos] = t;
        memcpy(tmp + pos + 1, 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 = 0;
    if ((count = last - first) <= 0)
        return;

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


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

        memcpy(tmp + pos + count, buff + pos, sizeof(T)*(len - pos));
        delete[] buff;
    }
    else
        for (int i = 0; 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 = 0;
}

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 == 0);
}

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;
}