// Temparr.C -example of array with templates

#include <iostream.h>

template <class Type>
class ArrayList{
  private:
    Type *arr;
    int arrSize;
  public:
    ArrayList(int sizeIn = 5);
    ArrayList (const ArrayList &other);
    ~ArrayList();
    ArrayList &operator=(const ArrayList &other);
    Type &operator[](int index);
    const Type &operator[](int index) const;
    int getSize() const;
  private:
    void copy(const ArrayList &other);
    void init();
    void freeMem();
};

// default constructor
template <class Type>
ArrayList<Type>::ArrayList(int sizeIn):arrSize(sizeIn){
  if (arrSize < 0)
    arrSize = 5;
    arr = new Type[arrSize];
}

// copy constructor
template <class Type>
ArrayList<Type>::ArrayList(const ArrayList &other){
  copy(other);
}

// overloaded operator=
template <class Type>
ArrayList<Type> & ArrayList<Type>::operator=(const ArrayList &other){
  if(this != &other){
    freeMem();
    copy(other);
  }
  return *this;
}

// destructor
template <class Type>
ArrayList<Type>::~ArrayList(){
  freeMem();
}

// copy helper
template <class Type>
void ArrayList<Type>::copy(const ArrayList &other){
  init();
  arrSize = other.arrSize;
  arr = new Type[arrSize];
}

// init helper
template <class Type>
void ArrayList<Type>::init(){
  arr = NULL;
  arrSize = 0;
}

// freeMem helper
template <class Type>
void ArrayList<Type>::freeMem(){
  delete [] arr;
  arr = NULL; 	// to be safe
}

// operator[] non-const version
template <class Type>
Type & ArrayList<Type>::operator[](int index){
  return arr[index];
}

// operator= const version
template <class Type>
const Type & ArrayList<Type>::operator[](int index) const{
  return arr[index];
}

// size
template <class Type>
int ArrayList<Type>::getSize() const{
  return arrSize;
}

main(){
  ArrayList<int> list(10);

  for(int i = 0; i < 10 ; i++){
    list[i] = 2*i;
    cout << list[i] << " ";
  }
  cout << endl;
  return 0;
}