Funktionsargument

Folgendes Problem:

eine globale funktion ist definiert durch:

double globfunc(MyClass obj, vector<double> x);

jetzt soll in einer klassenmethode der Klasse myClass ein funktionszeiger *f definiert werden, welcher auf die Funktion globfunc weiterleitet und dabei Argument obj mit dem Zeiger auf eigene Klasse belegt.

MyClass::Methode()
{
     double(*f)(vector<double> x) = globfunc[obj=this]; //sowas in der art
}

wie ist da die richtige schreibweise, gibt es solche Möglichkeit überhaupt?

Anmerkung:
f muss unbedingt vom Typ double(*)(vector<double>) sein!

eine klassenmethode MyClass::func(vector<double> x)
hat den Typ double(MyClass::*)(vector<double>) und kann auch nicht gematch werden bei
double(*f)(vector<double> x) = this->func

P.S.
wenn es alles nicht verständlich war dann:

wie matche ich double()() und double(class::)()

Tachyon

Das geht nicht. Die eine Member-Variante hat implizit this als Argument mit drin, die globale nicht. Wozu willst Du das denn machen?
Beschreib doch mal, was Du damit genau bezwecken willst.

ich habe:

Funktion f1:
double(*f1)(type1, type2)

Funktion f2
double(*f2)(type2)

ich brauche folgende "umleitung", "umwandlung":

type1 t; //initialisiert
...
f2 = f1(t,)

wie ist die richtige syntax???

Tachyon

Das erklärt es noch nicht. Wozu brauchst Du denn die Funktion mit dem reinen Double-Argument? Vor allem, wenn es IN der Klasse benutzt werden soll?
Und wieso als Funktionszeiger? In Deinem Beispiel ist es fest eingebrannt. Da bringt ein Funktionszeiger nichts.

Tachyon schrieb:

Das geht nicht. Die eine Member-Variante hat implizit this als Argument mit drin, die globale nicht. Wozu willst Du das denn machen?
Beschreib doch mal, was Du damit genau bezwecken willst.

der globalen werde ich die doch als Argument zuweisen...

Zweck:
die optimierungsmethode braucht einen funktionszeiger auf die Zeilfunktion
hat den type double(*)(vector<double>)
aufruf mit optimize(double(*f)(vector<double>))

in meiner klasse mit dem optimierungsproblem ist die Zielfunktion definiert
mit double (*Class::func)(vector<double>)

opmtimize(func) klappt nicht wegen "class::"

deswegen habe ich die globale funktion genommen, die braucht aber einige memberargumente, so dass ich der globalen funktion einfach noch alles mitgebe.

Tachyon

gutentagservus schrieb:

der globalen werde ich die doch als Argument zuweisen...

Wozu was nachbauen, was Dir C++ eh schon liefert?

Ich verstehe aus Deiner Beschreibung heraus nicht im geringsten, was Du vor hast. Bitte mal ganz genau beschrieben, und vielleicht mal etwas ordentlichen, kommentierten Code zeigen, der es vielleicht etwas klarer macht.

Welche Funktionen gibt es schon? Willst Du eine global existierende Optimierungsfunktion

double optimize(const vector<double>& vec)
{
   //do optimizations
}

Sollen irgendwelche Member-Methoden aus Klassen irgendwie global zur Optimierung von irgendwas zur Verfügung gestellt werden? So wird nichts klarer.

Tachyon schrieb:

Das erklärt es noch nicht. Wozu brauchst Du denn die Funktion mit dem reinen Double-Argument? Vor allem, wenn es IN der Klasse benutzt werden soll?
Und wieso als Funktionszeiger? In Deinem Beispiel ist es fest eingebrannt. Da bringt ein Funktionszeiger nichts.

IN der klasse wird nur der funktionszeiger definiert und danach dem optimierer zugewiesen. der optimierer arbeitet dann ne weile allein und ruft die funktion über den zeiger immer wieder auf.

auf globale funktion greift der optimierer ohne probleme zu und da funzt alles,
wenn ich mehrere probleme hab mit jeweils dazugehörigen zielfunktionen will ich für jedes problem eine klasse haben und in jeder klasse ein zielfunktion als member methode.

Dravere

Warum du das machen willst, geht daraus immer noch nicht hervor. Sowas ist zwar möglich umzusetzen, aber irgendwie erscheint es mir eher ein Designfehler zu sein.

Wieso übergibst du der Funktion optimize nicht einfach einen Zeiger oder eine Referenz auf dein Objekt?

Grüssli

Dravere schrieb:

Warum du das machen willst, geht daraus immer noch nicht hervor. Sowas ist zwar möglich umzusetzen, aber irgendwie erscheint es mir eher ein Designfehler zu sein.

Wieso übergibst du der Funktion optimize nicht einfach einen Zeiger oder eine Referenz auf dein Objekt?

Grüssli

diplomarbeit...
es wird eine optimierungsbilbliothek.

ich habe 3 fertige optimierer(freeware, sourcecode)
die brauchen jeweils nur die zielfunktion.

wenn es jetzt nicht klappt dann werde ich denen wie du sagst eine Referenz auf mein objekt übergeben. kostet wieder zeit.

bis jetzt habe ich in der main.cpp immer globale objekte für die optimierungsprobleme erzeugt,

Optproblem obj; //vor der main

//obj->zielfkt(x) liefert nen double;

dann habe ich extra globale funktion geschrieben
vor der main

double f(x)
{
  return obj->zielfkt(x);
}

dann in der main

double(*func)(vector<double>) = f;
opimize(..., func);

vorstellen tue ich mir das ganze so

[cpp]
double(func)(vector<double> x) = obj->zielfkt(x);
//matcht er nicht,
//weil zielkft double(OptProblem::)(vector<double> x) ist

optimize(..., func);
[/cpp]

Tachyon schrieb:

Welche Funktionen gibt es schon? Willst Du eine global existierende Optimierungsfunktion
double optimize(const vector<double>& vec)
{
   //do optimizations
}
Sollen irgendwelche Member-Methoden aus Klassen irgendwie global zur Optimierung von irgendwas zur Verfügung gestellt werden? So wird nichts klarer.

ich glaube "global" irritiert hier ein wenig.

hab einen otpimierer OPT

der kann optimieren mit

vector<double> OPT::do_it(const vector<double>& startparameter, double(*func)(vector<double>))

und gibt dann den optimierten vektor zurück

ich habe problemmklassen

ProbClass prob;

prob->zielfkt(vector<double> x) //gibt double

zum optimieren starte ich

OPT::do_it(prob->getstartparameter, prob->zielfkt)

und hier das matchproblem
func vs. prob->zielfkt
bzw.
double()(vector<double>) vs. double(ProbClass::)(vector<double>)

um dieses ProbClass:: wegzubekommen nehme ich eine globale funktion

double global(ProbClass *obj, vector<double> x)
{
   return obj->zielfkt(x);
}

bis hierhin klappt alles...
dann brauche ich für den optiemierer den benötigten fktzeiger
double(*func)(vector<double>)=global(this, vector<double>)
gibt es sowas, dass man fktzeiger auf funktion mit einer
variable auf funktion mit 2 variablen umleitet und eine variable
dabei belegt so dass wieder nur eine variable bleibt...

ich glaube ich fange schon mal mit der objektübergabe an...
p.s.
es geht doch nur um das matchen von funktionen...
alles andere ist überflüssig.

Tachyon

Das geht nicht. Du musst wohl oder übel das Interface Deines Optimierers so ändern, dass es eine Optimierungsproblem-Refferenz/Objekt übernimmt.

Du kannst Funktionen nicht "matchen". Funktionszeiger können nur auf Funktionen zeigen, die ein identisches Iterface haben, und double (MyClass, vector<T>) != double (vector<T>) . Egal, wie Du es wendest.

Tachyon schrieb:

Das geht nicht. Du musst wohl oder übel das Interface Deines Optimierers so ändern, dass es eine Optimierungsproblem-Refferenz/Objekt übernimmt.

Du kannst Funktionen nicht "matchen". Funktionszeiger können nur auf Funktionen zeigen, die ein identisches Iterface haben, und double (MyClass, vector<T>) != double (vector<T>) . Egal, wie Du es wendest.

alles klar... danke.

p.s. diese match-option muss dann aber trotzdem in c++ eingeführt werden

asc

gutentagservus schrieb:

p.s. diese match-option muss dann aber trotzdem in c++ eingeführt werden

Bin ich nicht der Meinung. Ein Methodenzeiger besteht nunmal aus zwei Komponenten und nicht nur einer wie bei einem Funktionszeiger. Wobei du dir durchaus mal die folgenden Bereiche ansehen könntest boost::bind + boost::function...

cu André

LordJaxom

Dann nutze Funktionsobjekte statt Funktionszeigern - natürlich auch in der Funktion, die den Funktionszeiger erwartet.

#include <tr1/function>
using namespace std::tr1;

function< double ( std::vector<double> const& ) > func = bind( &klasse::methode, &objektVonKlasse, placeholders::_1 );

std::vector< double > vec;
func( vec );