===================
Template-Funktionen   [TOC]
===================

Momentan musste der Programmtext für die Ausgabe der beiden
Matrizen dupliziert werden:

---- CODE (type=cpp) ----------------------------------------------------------
Matrix<double> A(7, 8, StorageOrder::ColMajor);
/* ... init A ... */
std::cout << "A:" << std::endl;
for (std::size_t i = 0; i < A.m; ++i) {
   for (std::size_t j = 0; j < A.n; ++j) {
      std::cout << " " << std::setw(8) << A(i, j);
   }
   std::cout << std::endl;
}

Matrix<float> B(3, 3, StorageOrder::RowMajor);
/* ... init B ... */
std::cout << std::endl << "B:" << std::endl;
for (std::size_t i = 0; i < B.m; ++i) {
   for (std::size_t j = 0; j < B.n; ++j) {
      std::cout << " " << std::setw(8) << B(i, j);
   }
   std::cout << std::endl;
}
-------------------------------------------------------------------------------

Das ist natürlich nicht sehr schön. Eine denkbare Option
wäre es, die Ausgabe als Methode in die _Matrix_-Klasse
zu integrieren. Aber das ist im Sinne des Software Engineering
nicht wünschenswert. Stattdessen sollten wir danach streben,
Klassen zu entwickeln, die

 * minimalistisch und
 * im ausreichenden Maße erweiterbar sind, so dass zukünftige
   Anwendungen nicht auf unüberwindbare Hindernisse stoßen.

Da die _Matrix_-Klasse bereits die Zugriff auf individuelle
Elemente unterstützt, könnten wir dies durch eine separate
Funktion erledigen. Für die ursprüngliche _Matrix_-Klasse
nur für `double` könnte dies wie folgt umgesetzt werden:

---- CODE (type=cpp) ----------------------------------------------------------
void print_matrix(const Matrix& A) {
   for (std::size_t i = 0; i < A.m; ++i) {
      for (std::size_t j = 0; j < A.n; ++j) {
	 std::cout << " " << std::setw(8) << A(i, j);
      }
      std::cout << std::endl;
   }
}
-------------------------------------------------------------------------------

Da C++ Template-Funktionen unterstützt, lässt sich 
das auch mit einer Template-Funktion erledigen,
die identisch zu oben ist, aber um ein Template-Konstrukt
ergänzt wird:

:import: session04/print-matrix.cpp

---- SHELL (path=session04) ------------------------
g++ -Wall -o print-matrix print-matrix.cpp
./print-matrix
---------------------------------------------------

Wie Sie hier sehen, werden beim Aufruf der Template-Funktion
die Template-Parameter nicht angegeben. Diese können in der
Tat entfallen, wenn der Übersetzer die Möglichkeit hat, diese
selbst anhand der übergebenen Parameter herzuleiten.

Aufgabe
=======

Ergänzen Sie das Beispiel um eine _init_-Funktion.
Sie können es zuerst mit einer Variante tun, die
die Initialisierung wie jetzt zuvor in einer festgelegten
Weise durchführt. Reizvoll wäre hier aber der Einsatz
von Lambda-Ausdrücken, für die Sie dann einen zweiten
Template-Parameter benötigen würden. Anwendungsbeispiel:

---- CODE (type=cpp) ----------------------------------------------------------
Matrix<double> A(7, 8, StorageOrder::ColMajor);
init_matrix(A, [&A](std::size_t i, std::size_t j) {
   return i * A.n + j;
});
std::cout << "A:" << std::endl; print_matrix(A);

Matrix<float> B(3, 3, StorageOrder::RowMajor);
init_matrix(B, [&B](std::size_t i, std::size_t j) {
   return j * B.m + i;
});
std::cout << std::endl << "B:" << std::endl; print_matrix(B);
-------------------------------------------------------------------------------

:navigate: up    -> doc:index
           back  -> doc:session04/page02
           next  -> doc:session04/page04