class Gleichungssystem
{
    Vec anfangswert;

    void Wert(Vec &in, Vec &out);

    void Solve();
}

Gleichungssystem::Solve()
{
    Lösungsverfahren(this->Wert)
}

nun die Frage: kann es sein daß ich eine Memberfunktion nicht per Funktionspointer übergeben kann, weil dann die beziehung zum speziellen Objekt verloren geht?
und falls ja, wie würdet ihr das Problem lösen?

Vielen dank im voraus,
Matthias

nun die Frage: kann es sein daß ich eine Memberfunktion nicht per Funktionspointer übergeben kann, weil dann die beziehung zum speziellen Objekt verloren geht?

Ja, das kann nicht nur so sein, das IST so.

und falls ja, wie würdet ihr das Problem lösen?

Methodenzeiger verwenden.

Kann man eigentlich nen Methodenzeiger in nen Funktionszeiger "casten"?

Was bringts dir?

Kann man eigentlich nen Methodenzeiger in nen Funktionszeiger "casten"?

Man kann zwar viel böse rumcasten, aber das würde der Compiler IMHO in jedem denkbaren Fall verhindern.

...kann es sein daß ich eine Memberfunktion nicht per Funktionspointer übergeben kann, weil dann die beziehung zum speziellen Objekt verloren geht?...

Also ich finde es super, dass Du da alleine drauf gekommen bist ! (ganz ernst gemeint)
In fast allen anderen Threads zu diesem Thema liegt der Grund genau darin, dass die Leute diesen Zusammenhang nicht beachtet haben.

Als mögliche "Lösungen" Zu Deinem Beispiel fallen mir ein: Lösungsverfahren() nimmt als Parameter

• ein "Gleichungssystem" oder
• eine gemeinsame Basisklasses (z.B. class hasWertFunktion ) oder
• einen Funktor

entgegen.
Zum Letzten:

void Loesungsverfahren(void (*)(Vec&, Vec&));

struct Gleichungssystem
{
    Vec anfangswert;

    void Wert(Vec &in, Vec &out);

    void Solve();
}

struct Wert_Funktion {
   Gleichungssystem& g;
   Wert_Funktion(Gleichungssystem& bezug) : g(bezug) {}
   void operator()(Vec &in, Vec &out) { g.Wert(in, out); }
};

Gleichungssystem::Solve()
{
   Wert_Funktion  wf(*this);
   Loesungsverfahren(wf);
}

Der Funktor "Wert_Funktion" "merkt" sich also den Bezug zum Objekt.

Gruß,

Simon2.

P.S.: Den Zugriff auf Klassenmember mittels "this->" finde ich unübersichtlich, überflüssig und "de-flexibilisierend".

Eine mögliche Lösung (ohne tr1) wäre, den Funktor als Template zu realisieren. Wenn die Signatur nicht stimmt, wird sich der Compiler schon beschweren

template<typename Func>
void Loesungsverfahren(Func f)
{
// hier f als funktion nutzen
    f(x,y);
}

struct Gleichungssystem
{
    Vec anfangswert;

    void Wert(Vec &in, Vec &out);

    void Solve();
};

struct Wert_Funktion {
    Gleichungssystem& g;
    Wert_Funktion(Gleichungssystem& bezug) : g(bezug) {}
    void operator()(Vec &in, Vec &out) { g.Wert(in, out); }
};

void Gleichungssystem::Solve()
{
    Wert_Funktion  wf(*this);
    Loesungsverfahren(wf);
}

Kurz zusammengefasst das wichtigste: Ein Funktor (oder Funktionsobjekt) ist ein Objekt, das wie eine Funktion verwendet werden kann. Das bedeutet letztendlich nur, daß die entsprechende Klasse den operator() überladen hat. (aber da sich dahinter ein vollwertiges Objekt befindet, ist ein Funktor um einiges mächtiger als eine normale Funktion).

// Datei nr.h
template<typename Func>
void broydn(Func f);

// Datei broydn.cpp. Das ist das Lösungsverfahren.
include "nr.h"
template<typename Func>
void broydn(Func f)
{
// hier f als funktion nutzen
    f(x,y);
}

// Datei Gleichungssystem.h
#include "nr.h"
struct Gleichungssystem
{
    Vec anfangswert;

    void Wert(Vec &in, Vec &out);

    void Solve();
};

// Datei Gleichungssystem.cpp
struct Wert_Funktion {
    Gleichungssystem& g;
    Wert_Funktion(Gleichungssystem& bezug) : g(bezug) {}
    void operator()(Vec &in, Vec &out) { g.Wert(in, out); }
};

// Datei Gleichungssystem.cpp
void Gleichungssystem::Solve()
{
    Wert_Funktion  wf(*this);
    Loesungsverfahren(wf);
}

Jetzt bekomme ich aber folgenden Fehler:

error LNK2019 unresolved external symbol "void __cdecl broydn<struct Wert_Funktion>...

Jetzt hab ich irgendwie nicht so recht eine Ahnung woran das liegt. Kann mir da nochmal jemand auf die Sprünge helfen?
Danke,
Matthias

...

// Datei nr.h
template<typename Func>
void broydn(Func f);

// Datei broydn.cpp. Das ist das Lösungsverfahren.
include "nr.h"
template<typename Func>
void broydn(Func f)
{
// hier f als funktion nutzen
    f(x,y);
}
...

Geht nicht !
Der Compiler muss die Implementation eines templates sehen =>

// Datei nr.h
template<typename Func>
void broydn(Func f)
{
// hier f als funktion nutzen
    f(x,y);
}

Ist übrigens der Standardfehler bei template-Anfängern ...

Gruß,

Simon2.