#include<stdio.h>
#include<stdlib.h>
 
// ********************
 
// Definition einer Klasse fuer Matrizen beliebiger Groesse.
 
class Matrix
{
public:  // Von aussen sichtbar.
 
  // Methoden.
 
  // Konstruktor: Reserviert entsprechend Speicher fuer die Matrixelemente,
  // initialisiert die Attribute (eine m_ x m_ Matrix, alle Eintraege 0.0). 
  Matrix(int m_);
 
  // Konstruktor: Reserviert entsprechend Speicher fuer die Matrixelemente,
  // initialisiert die Attribute (eine m_ x n_ Matrix, alle Eintraege 0.0). 
  Matrix(int m_, int n_);
 
  // Konstruktor: Kopiert eine bestehende Matrix.
  Matrix(const Matrix &A);
 
  // Destruktor: Gibt den fuer die Matrixelemente reservierten Speicher wieder
  // frei.
  ~Matrix();
 
  // Liefert den Wert des (i,j)-ten Matrixelements.
  double Get(int i, int j);
 
  // Setzt den Wert des (i,j)-ten Matrixelements auf den Wert von a.
  void Set(int i, int j, double a);
 
  // Gibt die Matrix am Bildschirm aus.
  void Print();
 
  // *****
 
private:  // Von aussen nicht sichtbar.
 
  // Wandelt Zeilenindex i und Spaltenindex j in den Index des Arrays
  // elements um; eine Hilfsfunktion fuer Get und Set, daher private.
  int Index(int i, int j);
 
  // Attribute.
  int m, n;  // Eine Matrix mit m Zeilen und n Spalten.
  double *elements;  // Die Matrixeintraege.
};
 
// Im Folgenden werden die in
//   class Matrix { ... }
// deklarierten Methoden definiert.
 
Matrix::Matrix(int m_)
{
  int i1;
 
  m = m_;
  n = m_;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = 0.0;
}
 
Matrix::Matrix(int m_, int n_)
{
  int i1;
 
  m = m_;
  n = n_;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = 0.0;
}
 
Matrix::Matrix(const Matrix &A)
{
  int i1;
 
  m = A.m;
  n = A.n;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = A.elements[i1];
}
 
Matrix::~Matrix()
{
  if(elements != NULL)
    free(elements);
}
 
int Matrix::Index(int i, int j)
{
  if(i < 0 || i >= m || j < 0 || j >= n)
    {
      fprintf(stderr, "Fehler in int Matrix::Index(...\n");
      exit(0);
    }
 
 return i*n + j;
}
 
double Matrix::Get(int i, int j)
{
  return elements[Index(i, j)];
}
 
void Matrix::Set(int i, int j, double a)
{
  elements[Index(i, j)] = a;
}
 
void Matrix::Print()
{
  int i1, i2;
 
  for(i1 = 0; i1 < m; i1++)
    {
      printf("| ");
 
      for(i2 = 0; i2 < n; i2++)
	{
	  printf("%+.3e ", Get(i1, i2));
	}
 
      printf("|\n");
    }
}
 
// ********************
 
int main(void)
{
  Matrix A(2);  // Matrix A(2, 2); wuerde ebenfalls funktionieren.
  A.Set(0, 0, 1.0);
  A.Set(1, 1, 1.0);
  printf("A =\n");
  A.Print();
 
  printf("********************\n");
 
  Matrix B(A);
  printf("B =\n");
  B.Print();
 
  printf("********************\n");
 
  A.Set(0, 0, 2.0);
  A.Set(1, 1, 3.0);
  printf("A =\n");
  A.Print();
  
  printf("********************\n");
 
  printf("B =\n");
  B.Print();
}

