=============================================
Repräsentierung einer Matrix mit einer struct                            [TOC]
=============================================

In den bisherigen Funktionen, die mit Matrizen operierten, wurden diese
durch eine Reihe von Parametern charakterisiert:

---- CODE (type=c) ------------------------------------------------------------
void
initMatrix(long m, long n, double *A, long incRowA, long incColA) {
   /* ... */
}
-------------------------------------------------------------------------------

Diese lassen sich sowohl in C als auch in C++ zu einer sogenannten `struct`
zusammenfassen:

---- CODE (type=c) ------------------------------------------------------------
struct Matrix {
   long m;
   long n;
   double* A;
   long incRowA;
   long incColA;
};
-------------------------------------------------------------------------------

Da es nicht sinnvoll erscheint, den Namen _A_ generell mit dem einer Matrix
zu verbinden, wird dieser gerne weggelassen. Der Zeiger auf die Daten wird
dann einfach `data` genannt:

---- CODE (type=cpp) ----------------------------------------------------------
struct Matrix {
   long m;
   long n;
   double* data;
   long incRow;
   long incCol;
};
-------------------------------------------------------------------------------

Wenn hier der erste Schritt zu C++ genommen wird, ist zu beachten, dass
bei einigen Implementierungen `long` kleiner sein kann als die Größe einer
Matrix. Sowohl in C als auch C++ lässt sich dafür `size_t` verwenden
(ohne Vorzeichen) oder auch alternativ `ptrdiff_t` (mit Vorzeichen).
In C++ gibt im Gegensatz zu C Namensräume und alle Namen aus der
Standardbibliothek sind im Namensraum `std`. Entsprechend verwenden wir
hier `std::size_t` anstelle von `size_t`:

---- CODE (type=cpp) ----------------------------------------------------------
#include <cstddef>

struct Matrix {
   std::size_t m;
   std::size_t n;
   std::size_t incRow;
   std::size_t incCol;
   double* data;
};
-------------------------------------------------------------------------------

C++ baut auf C auf und erlaubt auch die Nutzung von Typen und Funktionen
aus der Standard-Bibliothek für C. Es werden aber jeweils andere
Header-Namen verwendet. Aus `#include <stddef.h>` in C wird in C++
hier `#include <cstddef>`. Analog kann auch `std::printf` verwendet
werden nach `#include <cstdio>`.

C++ ist eine sogenannte objekt-orientierte Programmiersprache, die es
erlaubt, Funktionen mit einer einer `struct` (oder `class`) zu
verknüpfen. Diese Funktionen werden Methoden genannt. Eine Methode `init`
analog zum zuvor vorgestellten `initMatrix` könnte dann so aussehen:

---- CODE (type=cpp) ----------------------------------------------------------
struct Matrix {
   std::size_t m;
   std::size_t n;
   std::size_t incRow;
   std::size_t incCol;
   double* data;

   void init() {
      for (std::size_t i = 0; i < m; ++i) {
	 for (std::size_t j = 0; j < n; ++j) {
	    data[i*incRow + j*incCol] = j * n + i + 1;
	 }
      }
   }
};
-------------------------------------------------------------------------------

So könnte dazu passend eine Initialisierung und ein Aufruf der Methode
aussehen:

---- CODE (type=cpp) ----------------------------------------------------------
Matrix A;
A.m = 7; A.n = 8;
A.data = new double[A.m * A.n];
A.incRow = 1; A.incCol = 7;
A.init();
-------------------------------------------------------------------------------

Ein Methodenaufruf besteht immer aus einem Ausdruck, der ein Objekt liefert
(im Beispiel `A`), dem Namen der Methode (hier `init`) und der Parameterliste
(hier leer). Das referenzierte Objekt wird dabei zu einem impliziten Parameter.
Wenn innerhalb der Methode `init` auf eine Komponente der `struct` zugegriffen
wird wie etwa auf `data`, dann bezieht sich das immer auf das beim Aufruf der
Methode angegebene referenzierte Objekt.

Aufgabe
=======

Passen Sie das folgende Beispiel so an, dass aus der Funktion
`print_matrix` eine Methode `print` wird.

Vorlage
=======
:import: session7/matrix_class1.cpp

Übersetzen und Ausführen
========================

---- SHELL (path=session7) ------------------------
g++ -std=gnu++11 -o matrix_class1 matrix_class1.cpp
matrix_class1
---------------------------------------------------

:navigate: up    -> doc:index
           next  -> doc:session7/page02