#include <iostream.h>


// --------------------------------------------- MatrixNxN: Dynamic size matrix
class MatrixNxN
{
public:
   double *A;
   int    N;


   /* ------------------------------------------
      Constructors
      ------------------------------------------ */
   MatrixNxN()
   {
   }

   MatrixNxN(int n)
   {
      A = new double[n*n];
      N = n;
   }

   // The right way to copy a Matrix
   MatrixNxN( MatrixNxN & a)
   {
      int i, j;

      A = new double(a.N * a.N);    // Make a new array;

      N = a.N;

      for (i = 0; i < N; i = i + 1)
         for (j = 0; j < N; j = j + 1)
            A[i*N+j] = a.A[i*N+j];  // Copy elements
   }

   MatrixNxN operator+(double x)              
   {
      MatrixNxN out(N);
      int i, j;
               
      for (i = 0; i < N; i = i+1)
         for (j = 0; j < N; j = j+1)
            out.A[i*N+j] = A[i*N+j] + x;
               
      return(out);
   }
};

ostream & operator<<( ostream & output, MatrixNxN & x )         
{
   int i, j;

   for (i = 0; i < x.N; i = i + 1)
   {
      for (j = 0; j < x.N; j = j + 1)
         output << x.A[i*x.N+j] << "\t";
      output << endl;
   }

   return(output); 
}

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




int main(int argc, char *argv[])
{
   int i, j, k, N;

   N = 4;

   MatrixNxN m1(N);

   k = 1;
   for (i = 0; i < N; i = i + 1)
      for (j = 0; j < N; j = j + 1)
      {
         m1.A[i*N+j] = k;
         k = k + 1;
      }

   cout << "Matrix m1:" << endl << m1 << endl;

   MatrixNxN m2 = m1;

   cout << "Matrix m2:" << endl << m2 << endl;

   m1.A[0] = 10000.0;

   cout << "Matrix m1 after changing m1:" << endl << m1 << endl << endl;
   cout << "Matrix m2 after changing m1:" << endl << m2 << endl;

}