#include<stdio.h>
#include<stdlib.h>
 
// ********************
 
// Definition einer abstrakten Klasse fuer beliebige mathematische Objekte
// (Funktionen, Matrizen, etc.).
 
class MathObject
{
public:  // Von aussen sichtbar.
 
  // Gibt das mathematische Objekt am Bildschirm aus.
  // Unterklassen, z.B. Function, Matrix, ... koennen Print ueberschreiben;
  // virtual zeigt an, dass bei Verwendung eines Zeigers vom Typ MathObject
  // auf ein Objekt einer Unterklasse von MathObject die ueberschriebenen
  // Versionen von Print verwendet werden (--> Polymorphismus); siehe das
  // Beispiel in der main-Funktion.
  virtual void Print() const { };
};
 
// ********************
 
// Definition einer Klasse fuer beliebige Funktionen.
 
// Function erbt von MathObject, ist also eine Unterklasse von MathObject.
class Function : public MathObject
{
public:  // Von aussen sichtbar.
 
  // Wertet die Funktion bei x aus.
  double Eval(double x) const;
 
  // Gibt die Funktion am Bildschirm aus.
  void Print() const;
};
 
double Function::Eval(double x) const
{
  // Momentan immer die 0-Funktion ... Klasse ist noch nicht vollstaendig
  // implementiert.
  return 0.0;
}
 
void Function::Print() const
{
  printf("function(x) = ... (Klasse ist noch nicht vollstaendig implementiert.)\n");
}
 
// ********************
 
// Definition einer Klasse fuer Matrizen beliebiger Groesse.
 
// Matrix erbt von MathObject, ist also eine Unterklasse von MathObject.
class Matrix : public MathObject
{
public:  // Von aussen sichtbar.
 
  // Methoden.
 
  // Konstruktor: Reserviert entsprechend Speicher fuer die Matrixelemente,
  // initialisiert die Attribute (eine m_ x n_ Matrix, allen 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) const;
 
  // Liefert den Wert des (i,j)-ten Matrixelements.
  void Set(int i, int j, double a);
 
  // Gibt die Matrix am Bildschirm aus.
  void Print() const;
 
  int Get_m(void) const { return m; }
  int Get_n(void) const { return n; }
 
  // *****
 
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) const;
 
  // Attribute.
  int m, n;  // Eine Matrix mit m Zeilen und n Spalten.
  double *elements;  // Die Matrixeintraege.
};

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) const
{
  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) const
{
  return elements[Index(i, j)];
}
 
void Matrix::Set(int i, int j, double a)
{
  elements[Index(i, j)] = a;
}
 
void Matrix::Print() const
{
  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)
{
  int i1;
 
  // *****
 
  Matrix A(2, 2);
  A.Set(0, 0, 1.0);
  A.Set(1, 1, 2.0);
 
  Matrix B(2, 1);
  B.Set(0, 0, 3.0);
  B.Set(1, 0, 4.0);
 
  Function f;
 
  // *****
 
  MathObject *mo[3];
  mo[0] = &A;
  mo[1] = &f;
  mo[2] = &B;
 
  // Das Array enthaelt jetzt drei mathematische Objekte, eine 2x2-Matrix,
  // eine Funktion, eine 2x1-Matrix.
 
  for(i1 = 0; i1 < 3; i1++)
    // Beim Aufruf von Print werden aufgrund der virtual-Definition von Print
    // in MathObject die in den Unterklassen (Function, Matrix)
    // ueberschriebenen Versionen von Print verwendet (--> Polymorphismus).
    mo[i1]->Print();
}

