C++ Klassen-Methoden per Funktionspointer übergeben

[Jochen (Gast)]

Hallo,

folgende Problematik.

Ich habe zwei generische Funktionen geschrieben, die Minimum und Maximum 
einer Funktion finden. Das Interface sieht so aus:

// Iteratively find a local minimum or maximum of a
// function in a given interval

// The function to be minimized / maximized takes one
// double argument and returns a double:

typedef double(*fnptr_type)(double);

// - lower_bound and upper_bound define the initial search interval
// - the iteration stops when max_iterations have been performed
//   or the current search interval is smaller than residual_error

double find_minimum(fnptr_type fnptr, double lower_bound, double upper_bound, double residual_error, int max_iterations);
double find_maximum(fnptr_type fnptr, double lower_bound, double upper_bound, double residual_error, int max_iterations);

Jetzt würde ich gerne aus einer Klasse heraus, für eine Methode dieser 
Klasse, ein Minimum suchen.

Also zum Beispiel mit calculate_this aus dieser Klasse:

class t_technical_thing
{

    public:

        explicit t_technical_thing(double some_initial_value);
        void update_simulation(double delta_time);

    private:

        double calculate_this(double some_input);
        double caclulate_that(double some_other_input);

};

So hatte ich mir die Benutzung vorgestellt:

  double min_this = find_minimum(calculate_this, 0.1, 1.0, 0.001, 20);

Jetzt kann ich die Methoden-Klasse nicht als Funktionspointer übergeben, 
weil Typ und Kontext nicht stimmen. Wie löst man so ein Problem am 
besten?

Sollte ich die Klasse technical_thing von einer Mimimizer-Klasse 
ableiten? Oder gibt es einen sinnvollen Weg, den Typ zu casten, so dass 
die Übergabe des Funktionspointers klappt?

Ich hoffe das Problem ist verständlich beschrieben.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Du solltest das Interface Deiner Funktion auf `std::function< 
dobule(double) >` ändern. Dann kann der Aufrufer beliebige 
Konvertierungen verwenden, um alles mögliche auf diese Form zu bringen 
(z.b. auch Funktionen mit mehreren Parametern).

[Niklas G. (erlkoenig)]

Wenn du std::function akzeptierst, kannst du mit std::bind auch 
Member-Funktionen übergeben. Alternativ kann man auch Lambdas nehmen, 
was etwas intuitiver ist:

#include <iostream>
#include <functional>

double find_minimum(std::function<double(double)> f, double lower_bound, double upper_bound, double residual_error, int max_iterations) {
  return f (42);
}

double fun2 (double x) { return 3*x; }

class X {
  public:
    double fun (double x) { return 2*x; }
    void foo () {
      // Variante mit std::bind
      std::cout << find_minimum (std::bind(&X::fun, this, std::placeholders::_1), 1, 2, 3, 4) << std::endl;
      // Variante mit Lambda
      std::cout << find_minimum ([&] (double x) { return fun (x); }, 1, 2, 3, 4) << std::endl;

      // Normale Funktion
      std::cout << find_minimum (fun2, 1, 2, 3, 4) << std::endl;
    }
};

int main () {
  X x;
  x.foo ();
}

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Alternativ könntest Du aus Deinen Funktionen aber auch ein Template 
machen, und die Funktion als "etwas" (T) übergeben, dass sich wie eine 
Funktion (double (double)) verhält:

template < typename T >
double find_minimum(T func, double lower_bound, double upper_bound, double residual_error, int max_iterations)
{
   ...
   const double val = func( ... );
   ...
}

[Rufus Τ. F. (rufus)]

Herkömmliche Funktionspointer auf Memberfunktionen funktionieren nur 
ohne "this"-Pointer, dazu müssen sie als static deklariert werden.

static hat damit in C++ eine komplett andere Bedeutung als in C.

Wenn eine Memberfunktion einer Klasse mit einer Objektinstanz arbeiten 
soll, muss der benötigte "this"-Pointer als Argument beim 
Funktionsaufruf mitgegeben und in der Memberfunktion jeweils explizit 
genutzt werden.

[Rolf M. (rmagnus)]

Rufus Τ. F. schrieb:
> Herkömmliche Funktionspointer auf Memberfunktionen funktionieren nur
> ohne "this"-Pointer, dazu müssen sie als static deklariert werden.
>
> static hat damit in C++ eine komplett andere Bedeutung als in C.

Naja, C++ hat einen Kontext (Klassen), den es in C nicht gibt. An den 
Stellen, wo es auch in C static gibt, hat es die selbe Bedeutung wie in 
C++.