/*

  28/02/01 12:55 Kenneth L Moore/Charles McNeil

  This file shows a shallow copy error:

  If you compile and execute this file, when you examine the address of the
  array in object C, you will find that it is the same as the address of B.
  Therefore, if B gets deleted, C will point to nothing.

  If you take the comments out from around the overloaded assignment operator
  and run this file, you will find that C gets its own array.


*/

#include <iostream>
#include <stdlib.h>
using namespace std;



template <class T> class Array {

  size_t len; // size of array

  public:

    T *arr; // pointer to actual array
    Array(): len(5) {arr = new T[len];}
    Array(int n): len(n) {arr = new T[len];} // used to initialize to len
    Array(int n, const T& t); // array of len n filled w/t
    Array(const Array<T>& src); // copy constructor (duh)
    //~Array() {delete[] arr;} //almighty destructor



    virtual void print() {cout << "print method error" << endl;}
    size_t size() const {return len;}
    T& get(int i);
    void put(const T& x, int i);
    void fill(const T& x);
    T& operator[](int i);

};



//----------------------------------------------------------------------

// longer constructors



template <class T>
Array<T>::Array(int n, const T& t): len(n) {
  arr = new T[len];
  for(size_t i = 0; i < len; i++) {
    arr[i] = t;
  }
}



template<class T>
Array<T>::Array(const Array<T>& src): len(src.len) {
  arr = new T[len];
  for(size_t i = 0; i < len; i++) {
    arr[i] = src.arr[i];
  }
}


template <class T>
T& Array<T>::get(int i) {
  return arr[i];
}


template<class T>
void Array<T>::put(const T& x, int i) {
  arr[i] = x;
}


template<class T>
void Array<T>::fill(const T& x) {
  for(int i = 0; i < size(); i++) {
    arr[i] = x;
  }

}



//----------------------------------------------------------------------

// el overrido
template<class T>
T& Array<T>::operator[] (int i) {
  return arr[i];
}



//----------------------------------------------------------------------

// build the NumbArray class
template <class T> class NumbArray : public Array<T> {

  public:

    NumbArray(void): Array<T>() {}
    NumbArray(int n): Array<T>(n) {}
    NumbArray(int n, T const& t): Array<T>(n, t) {}
    NumbArray(NumbArray<T> const& src): Array<T>(src) {}
	void puts(T toPut, int loc){put(toPut, loc);}
    ~NumbArray(void) {}

    void print(){
      cout << "arr pointer " << arr << endl;
      for(int i = 0; i < size(); i++) {
        cout << i << " " << get(i) << endl;
      }
    }

/*
    NumbArray& operator=(NumbArray<T>& arg) {
    if(&arg != this)
      for(int i = 0; i < size(); ++i) {
        operator[](i) = arg[i];
      }
      return *this;
    }
*/
};



//-----------------------------------------------------------------------------



int main(int argc, char *argv[]) {



  NumbArray<int> A(5,14);
  NumbArray<int> B(A);
  NumbArray<int> C;

  A.print();
  B.print();

 
  C = B;
  B.puts(123,1);
  C.print();

  return 0;

}