面试题(C++10:Autodesk)

实现一个简单的vector, 以后随时更新bug.
//////////////////////////////////

#include <iostream>
using namespace std;
#define MAX 20

template <typename T>
class MyVector
{
public:
       typedef T * iterator;
      
private:
        T *m_items;
        int m_size;
        int m_capacity;
       
        iterator m_begin;
        iterator m_end;
       
public:
       MyVector(int size = 0);
       MyVector(iterator begin, iterator end);
       ~MyVector();
      
       int Size() const {return m_size;}
       int Capacity() const {return m_capacity;}
       iterator begin();
       iterator end();
      
       void push_back(const T& elem);
       T pop_back();
       void reserve(int newSize);
      
       T & operator[](int index);
};

template <typename T>
MyVector<T>::MyVector(int size)
{
   if (size == 0)
   {
      m_items = new T();
      m_size = 0;
      m_capacity = MAX;
   }
   else
   {
       m_size = size;
       m_capacity = 2 * m_size;
       m_items = new T[m_capacity];
       for (int i = 0; i < m_size; ++ i)
       {
           m_items[i] = 0;
       }
   }      
   m_begin = &m_items[0];
   m_end = &m_items[m_size];

}

template <typename T>
typename MyVector<T>::iterator MyVector<T>::begin()
{
   return m_begin;
}

template <typename T>
typename MyVector<T>::iterator MyVector<T>::end()
{
   return m_end;
}

template <typename T>
void MyVector<T>::reserve(int newSize)
{
     if (newSize >= m_capacity)
     {
         m_capacity = newSize;
     }
}

template <typename T>
void MyVector<T>::push_back(const T & elem)
{
     if (m_size >= m_capacity)
     {
         reserve(2*m_capacity + 1);
     }
    
     m_items[m_size] = elem;
    
     m_size ++;
    
     m_end++;
}

template <typename T>
T MyVector<T>::pop_back()
{
    if (m_size != 0)
    {
       return m_items[(m_size--)-1];
    }                    
}

template <typename T>
MyVector<T>::~MyVector()
{
   if (m_items != 0)
   {
      m_end --;
      delete[] m_items;
   }                                               
}

template <typename T>
T &MyVector<T>::operator[] (int index)
{
   assert(index >=0 && index < m_size);                          

   return m_items[index];
}

int main()
{
    MyVector<int> vec1;

    vec1.push_back(2);
    vec1.push_back(3);
    vec1.push_back(4);
   
    cout << "Test Senario1:" << endl;
    cout << "Size : " << vec1.Size();
    cout << " Capacity: " << vec1.Capacity();
   
    for (MyVector<int>::iterator iter = vec1.begin(); iter != vec1.end(); ++ iter)
    {
        cout << "Item : " << *iter << endl;
    }
   
    
    vec1.pop_back();
    cout << "Test Senario2:" << endl;
    cout << "Size : " << vec1.Size();
    cout << " Capacity: " << vec1.Capacity();
   
    MyVector<int> vec2(10);
    vec2.push_back(5);
    cout << "Test Senario3:" << endl;
    cout << "Size : " << vec2.Size();
    cout << " Capacity: " << vec2.Capacity();
   
    // cout << "Vector[-1]" << vec2[-1];
    cout << "Vector [1]" << vec2[1];
    cout << "Vector [11]" << vec2[10];   
   
    getchar();
}