// MT2Q2.cpp

#include <iostream>

template <typename T>
class array
{
public:
  array(size_t n=5) : pT_(new T[n]), size_(n), capacity_(n)
  {
    for(size_t i=0; i<n; ++i)
      pT_[i] = 0;
  }
  array(const array& arr) : size_(arr.size_), capacity_(arr.capacity_)
  {
    pT_ = new T[arr.capacity_];
    for(int i=0; i<arr.capacity_; ++i)
      pT_[i] = arr.pT_[i];
  }
  ~array(){ delete [] pT_; }
  array& operator=(const array& arr)
  {
    if(this == &arr) return *this;
    delete pT_;
    pT_ = new T[arr.size_];
    for(int i=0; i<arr.capacity_; ++i)
      pT_[i] = arr.pT_[i];
  }
  T& operator[](size_t n)
  {
    if(n<0 || size_ <= n)
      throw std::exception("index outside bounds of array");
    return pT_[n];
  }
  T operator[](size_t n) const
  {
    if(n<0 || size_ <= n)
      throw std::exception("index outside bounds of array");
    return pT_[n];
  }
  void append(const T& t)
  {
    if(capacity_ == size_)
      resize(2*size_);
    pT_[size_++] = t;
  }
  size_t size() { return size_; }
private:
  void resize(size_t newCapacity)
  {
    if(newCapacity <= capacity_)
      throw std::exception("new capacity must be larger than old");
    else
      capacity_ = newCapacity;
    T* temp = new T[capacity_];
    for(size_t i=0; i<size_; ++i)
      temp[i] = pT_[i];
    for(size_t i=size_; i<capacity_; ++i)
      temp[i] = 0;
    delete [] pT_;
    pT_ = temp;
  }
  T* pT_;
  size_t size_, capacity_;
};

template <typename T>
void show(array<T>& arr)
{
  std::cout << "\n  ";
  for(size_t i=0; i<arr.size(); ++i)
    std::cout << arr[i] << " ";
  std::cout << "\n";
}

void main()
{
  array<int> arr(3);
  try
  {
    arr[0] = 0;
    arr[1] = 1;
    arr[2] = 2;
    arr.append(3);
    arr.append(4);
    arr.append(5);
    arr.append(6);

    // will throw exception - outside bounds of array
    // arr[7] = 7;

    show(arr);
    array<int> copy = arr;
    show(copy);
  }
  catch(std::exception& ex)
  {
    std::cout << "\n  " << ex.what();
  }
}