================
Lösungsvorschlag
================

Zur ersten Frage: Das `RandomValues`-Objekt ist zunächst ein
temporäres Objekt, das dann durch die Parameterübergabe
kopiert und dadurch in `initGeMatrix` zu einem lokalen
Objekt wird. Bei der Parameterübergabe wird implizit
der _copy constructor_ aufgerufen. Da kein expliziter
gegeben ist, werden per Voreinstellungen alle einzelnen
Komponenten, also `mt` und `uniform`, kopiert.

Zur zweiten Frage: Der Datentyp `std::random_device` hat
keinen _copy constructor_. Deswegen klappt die
Parameterübergabe nicht, wenn es in `RandomValues`
es eine entsprechend deklarierte Variable gibt.
Deswegen wurde hier `std::random_device()()`
verwendet. Das erste Klammernpaar ist für den Aufruf
des Konstruktors. Bei dem so temporär erzeugten Objekt
wird dann der Funktionsoperator aufgerufen. Hierzu ist
das zweite Klammernpaar notwendig.

Beim dritten Punkt war es nur notwendig, die Funktion
`initGeMatrix` in `bench.h` zu vereinfachen, d.h. der
dritte und vierte Parameter wurden einfach gestrichen:

---- CODE (type=cpp) ----------------------------------------------------------
template <typename T, typename Index, typename InitValue>
void
initGeMatrix(Index m, Index n, T *A, Index incRowA, Index incColA,
             InitValue initValue)
{
    for (Index j=0; j<n; ++j) {
        for (Index i=0; i<m; ++i) {
            A[i*incRowA+j*incColA] = initValue(i, j);
        }
    }
}
-------------------------------------------------------------------------------

So lässt sich die `RandomValues`-Klasse in Bezug auf
die vierte Frage um einen weiteren Konstruktor für
reproduzierbare Zahlenfolgen ergänzen:

---- CODE (type=cpp) ----------------------------------------------------------
template<typename T, typename Index>
struct RandomValues {
   std::mt19937 mt;
   std::uniform_real_distribution<T> uniform;
   
   RandomValues() :
      mt(std::random_device()()), uniform(-100, 100) {
   }
   RandomValues(unsigned int seed) :
      mt(seed), uniform(-100, 100) {
   }
   T operator()(Index i, Index j) {
      return uniform(mt);
   }
};
-------------------------------------------------------------------------------

Und so könnte `IncreasingRandomValues` aussehen:

---- CODE (type=cpp) ----------------------------------------------------------
template<typename T, typename Index>
struct IncreasingRandomValues {
   std::mt19937 mt;
   std::uniform_real_distribution<T> uniform;
   T last_value;
   
   IncreasingRandomValues() :
      mt(std::random_device()()), uniform(0, 1<<16), last_value(0) {
   }
   IncreasingRandomValues(unsigned int seed) :
      mt(seed), uniform(1, 1<<16) {
   }
   T operator()(Index i, Index j) {
      last_value += uniform(mt);
      return last_value;
   }
};
-------------------------------------------------------------------------------

Hier sind alle Dateien zum Lösungsvorschlag:

:import: session11/step04/bench.h
:import: session11/step04/gematrix.h
:import: session11/step04/test_initmatrix.cpp

:navigate: up    -> doc:index
           back  -> doc:session11/page03
           next  -> doc:session11/page05