T fold(T (*func) (T, T), T begin) const;

Angenommen ich hab nun ein Matrix<double>-Objekt m und möchte sowas hier aufrufen:

double d = m.fold(operator+, 0.0);

Es kommt die folgende Fehlermeldung:

..\src\LinearAlgebra.cpp:121:23: Fehler: keine passende Funktion für Aufruf von »Matrix<double>::fold(<unresolved overloaded function type>, double)«
..\src\LinearAlgebra.cpp:121:23: Anmerkung: Kandidaten sind:
In file included from ..\src\LinearAlgebra.cpp:6:0:
..\src\matrix.h:171:5: Anmerkung: T Matrix<T>::fold(T (*)(T, T), T) const [with T = double]
..\src\matrix.h:171:5: Anmerkung:   keine bekannte Umwandlung für Argument 1 von »<unresolved overloaded function type>« nach »double (*)(double, double)«

Kann man sowas wie operator+ einfach nicht als Parameter übergeben? Oder hat der operator+ für double einfach einen anderen Typ als ich denke?

auto double_add_operator = static_cast<double(double, double)>(operator+);

Allerdings kann es sein, dass das mit Operatoren für eingebaute Typen nicht funktioniert, weil sie keine richtige Implementierung besitzen.

Eine bessere Wahl wäre so etwas wie

template <typename F>
T fold(F func, T begin) const;

Dann funktioniert auch std::multiplies<T>

Edit: Ja, Funktionspointer ist natürlich Quatsch. Siehe camper.

Nur das hier:

double d = m.fold(std::plus<double>, 0.0);

funktioniert noch nicht:

..\src\LinearAlgebra.cpp:121:30: Fehler: expected primary-expression before »,« token

Der Lambda-Ausdruck geht.

Edit:
Ich habs schon, es muss heißen:

double d = m.fold(std::plus<double>(), 0.0);

Vorher ging das hier:

m.fold(std::min, 0.0)

Jetzt nicht mehr, was ja auch logisch ist, da std::min nicht mehr eindeutig ist.
Was wäre die eleganteste Lösung ohne C++11 (d.h. u.a. ohne Lambda-Ausdruck)?

Ich hätte jetzt gedacht, dass

m.fold(std::min<double>, 0.0)

funktionieren müsste, das tut es aber nicht:

Fehler: keine passende Funktion für Aufruf von »Matrix<double>::fold(<unresolved overloaded function type>, double)«

Eine Lösung, die funktioniert, die ich aber nicht vollständig verstehe ich folgende:
Matrix<T> hat das alte

T fold(T (*func) (T, T), T begin) const;

neben dem neuen

template <class F>
T fold(F func, T begin) const;

Prinzipiell könnte aber das F der zweiten fold-Methode doch gleich T()(T,T) sein oder? Das heißt, dass eine Methode mit dem gleichen Namen und den gleichen Parametern zweimal vorkommt. Oder wird einfach zunächst überprüft, ob T()(T,T) passt und falls nicht die zweite fold-Methode benutzt?

Wie würdet ihr das genannte Problem lösen?

static_cast<double(double, double)>(std::min)

Vorher ging das hier:

m.fold(std::min, 0.0)

Ist dein T eine Referenz auf const?

template <class T>
template <class F>
T Matrix<T>::fold(F func, T erg) const {
	for (int i = 0; i < dim1_; i++)
		for (int j = 0; j < dim2_; j++)
			erg = func(erg, getEntry(i,j));
	return erg;
}

template <class T>
template <>  // hier Fehler: invalid explicit specialization before »>« token
             //              einschließende Klassentemplates werden nicht explizit spezialisiert
T Matrix<T>::fold(T(*func)(T,T), T erg) const { // Fehler: Template-ID »fold<>« für »T Matrix<T>::fold(T (*)(T, T), T) const« passt zu keiner Templatedeklaration
	for (int i = 0; i < dim1_; i++)
		for (int j = 0; j < dim2_; j++)
			erg = func(erg, getEntry(i,j));
	return erg;
}

@camper:
T = double

Warum willst du die Funktion spezialisieren und nicht überladen?

Unwissenheit xD

Danke für den Link.

template<class T> const T& min(const T& a, const T& b);
template<class T, class Compare>
const T& min(const T& a, const T& b, Compare comp);
template<class T>
T min(initializer_list<T> t);
template<class T, class Compare>
T min(initializer_list<T> t, Compare comp);

Deshalb reicht es nicht, den Templateparameter explizit anzugeben. Anderseits ist mir auch nicht ganz klar, wie daraus ein double(double,double) entsehen soll..