自己实现迷你vector

/**//* my implemention of vector */
#include <iostream>
#include <exception>
#include <cassert>
using   namespace   std;

template <class T>
class MiniVector
...{
public:
    MiniVector(int size = 0);
    ~MiniVector();
    MiniVector& operator=(const MiniVector &rv);
    MiniVector(const MiniVector &rv);
    void PushBack(const T &item);
    void PopBack();
    T& Front();
    T& Back();
    int Size() const;
    bool IsEmpty() const;
    int Capacity() const;
    T& operator[](int i);
private:
    int size;
    int capacity;
    T *pAddr;
    void Reserve(int capacity, bool copy);
};

template <class T>
void MiniVector<T>::Reserve(int n, bool copy)
...{
    T *temp;
    if (n < this->capacity)
    ...{
        return;
    }
    try
    ...{
        temp = new T[n];
    }
    catch (bad_alloc &e)
    ...{
        cout << e.what();    
    }
    if (copy)
    ...{
        for (int i = 0; i < size; i++)
        ...{
            temp[i] = pAddr[i];
        }
    }
    if (pAddr != NULL)
    ...{    
        delete pAddr;
    }
    capacity = n;
    pAddr = temp;
}

template <class T>
MiniVector<T>::MiniVector(int size /**//* = 0 */)
...{
    if (0 == size)
    ...{    
        this->size = 0;
        capacity = 0;
        pAddr = NULL;
        return;
    }
    Reserve(size, false);
    this->size = size;
    for (int i = 0; i < size; i++)
    ...{
        pAddr[i] = T();
    }
}

template <class T>
MiniVector<T>::MiniVector(const MiniVector<T> &rv)
...{
    this->capacity = 0;
    this->size = 0;
    this->pAddr =NULL;
    Reserve(rv.size, false);
    for (int i = 0; i < rv.size; i ++)
    ...{
        pAddr[i] = rv.pAddr[i];
    }
    this->size = rv.size;
}

template <class T>
MiniVector<T>& MiniVector<T>::operator =(const MiniVector<T> &rv)
...{
    if (capacity < rv.size)
    ...{
        Reserve(rv.size, false);
    }
    for (int i = 0; i < rv.size; i ++)
    ...{
        pAddr[i] = rv.pAddr[i];
    }
    this->size = rv.size;
    return *this;
}

template <class T>
T& MiniVector<T>::operator [](int i)
...{
    assert(i > 0 && i < size);
    return pAddr[i];
}

template <class T>
void MiniVector<T>::PushBack(const T &item)
...{
    if (size == capacity)
    ...{
        if (0 == capacity)
        ...{        
            Reserve(1, false);
        }
        else
            Reserve(2 * capacity, true);
    }
    pAddr[size] = item;
    size++;
}

template <class T>
void MiniVector<T>::PopBack()
...{
    if (IsEmpty())
    ...{
        cout << "empty vector, popback failed!" << endl;
        return;
    }
    size--;
}

template <class T>
bool MiniVector<T>::IsEmpty() const
...{
    return size == 0;
}

template <class T>
int MiniVector<T>::Size() const
...{
    return size;
}

template <class T>
int MiniVector<T>::Capacity() const
...{
    return capacity;
}

template<class T>
T& MiniVector<T>::Front()
...{
    assert(!IsEmpty());
    return pAddr[0];
}

template<class T>
T& MiniVector<T>::Back()
...{
    assert(!IsEmpty());
    return pAddr[size - 1];
}

template <class T>
MiniVector<T>::~MiniVector()
...{
    if (pAddr != NULL)
    ...{
        delete[] pAddr;
        pAddr = NULL;
    }
}