#include <iostream.h>


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

   /* ------------------------------------------
      Constructor(int)
      ------------------------------------------ */
   MatrixNxN(int n)
   {
      cout << "Allocating an nxn float matrix, with n = " << n << endl << endl;
      A = new double[n*n];
      N = n;
   }

   void operator=(MatrixNxN & m2)
   {
      int i, j;
   
      cout << "Calling MatrixNxN::operator=(MatrixNxN) " << endl << endl;
   
      if ( N != m2.N )
      {
         cout << "** Error: Unequal size matrices ..." << endl << endl;
         return;
      }
   
      for (i = 0; i < N; i=i+1)
         for (j = 0; j < N; j=j+1)
            A[i*N+j] = m2.A[i*N+j];
   }
};


ostream & operator<<(ostream & cout, MatrixNxN &m)
{
   int i, j;

   for (i = 0; i < 3; i = i+1)
   {
      for (j = 0; j < 3; j = j+1)
         cout << m.A[i*m.N + j] << "  ";
      cout << endl;
   }
   cout << endl;

   return cout;
}

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




int main(int argc, char *argv[])
{
   int N = 3;
   MatrixNxN A(N), B(N);

   int i, j, k;

   A.A[0*N+0] = 1.0; A.A[0*N+1] = 0.0; A.A[0*N+2] = 0.0;
   A.A[1*N+0] = 1.0; A.A[1*N+1] = 1.0; A.A[1*N+2] = 0.0;
   A.A[2*N+0] = 1.0; A.A[2*N+1] = 1.0; A.A[2*N+2] = 1.0;

   cout << "Initial matrix A:" << endl << A << endl;

   B = A;

   cout << "matrix B = A:" << endl << A << endl;

   B.A[0] = 1000;

   cout << endl << "After : B.A[0][0] = 1000" << endl << endl;


   cout << "matrix A:" << endl << A << endl << endl;
   cout << "matrix B:" << endl << B << endl << endl;
}