#include <exception>
#include <iostream>

using namespace std;

// All definitions are outside the class template.
// For an alternative implementation, see array1d.cpp.

template <typename T>
class Array {
 public:
  Array(unsigned int n = 0, int b = 0);
  Array(const Array &a);
  ~Array();

  Array &operator=(const Array &a);

  const T &operator[](int i) const;
  T &operator[](int i);

 protected:
  T *data;
  int base;
  unsigned int length;

  unsigned int loc(int i) const;
};

template <typename T>
Array<T>::Array(unsigned int n, int b) : data(new T[n]), base(b), length(n) {}

template <typename T>
Array<T>::Array(const Array<T> &a)
    : data(new T[a.length]), base(a.base), length(a.length) {
  for (unsigned int i = 0; i < length; ++i)
    data[i] = a.data[i];
}

template <typename T>
Array<T>::~Array() {
  delete[] data;
}

template <typename T>
Array<T> &Array<T>::operator=(const Array<T> &a) {
  if (&a != this) {
    delete[] data;
    base = a.base;
    length = a.length;
    data = new T[length];
    for (unsigned int i = 0; i < length; ++i)
      data[i] = a.data[i];
  }
  return *this;
}

template <typename T>
unsigned int Array<T>::loc(int i) const {
  const int offset = i - base;
  if (offset < 0 || offset >= length)
    throw out_of_range("invalid array index");
  return offset;
}

template <typename T>
T &Array<T>::operator[](int i) {
  return data[loc(i)];
}

template <typename T>
const T &Array<T>::operator[](int i) const {
  return data[loc(i)];
}

int main() {
  Array<int> a(10, 1);
  for (int i = 1; i <= 10; ++i)
    a[i] = i * (i + 1) / 2;
  Array<int> b;
  const Array<int> c(a);
  b = c;
  a[2] = 17;
  b[3] = 42;
  for (int i = 1; i <= 10; ++i)
    cout << i << ": " << a[i] << " " << b[i] << " " << c[i] << endl;
}