ich arbeite gerade an meinem ersten größeren c++-projekt und könnte hier etwas hilfe gebrauchen. und zwar möchte ich einer funktion eine andere memberfunktion als parameter übergeben.
hier erstmal der code:

float quad2d::gauss2d(float (*func)(float x, float y))
{
	nrfunc=func;
	return gauss(f1);
}

float quad2d::f1(float x)
{
	xsav=x;
	return gauss(&quad2d::f2);
}

float quad2d::f2(float y)
{
	return (*nrfunc)(xsav,y);
}

class quad2d : public quad {
public:
	...
private:
	...
	float xsav;
	float (*nrfunc)(float,float);
	float f1(float), f2(float);
};

class quad {
public:
	float gauss (float (*)(float));
protected:
	...
};

das problem liegt beim aufrauf der gauss()-funktion. ich hab nu auf verschiedene arten versucht die funktion zu übergeben, zwei hab ich hier mal angegeben. ich bekomme dabei immer fehlermeldungen in der art:

error C2664: 'quad::gauss': Konvertierung des Parameters 1 von 'float (__thiscall quad2d::* )(float)' in 'float (__cdecl *)(float)' nicht möglich
1> Es gibt keinen Kontext, in dem diese Konvertierung möglich ist

ich hab doch nun eigentlich jeweils einen funktionszeiger mir float-parameter und float-rückgabe. der einzige unterschied ist cdecl und thiscall, von denen ich nicht wirklich verstanden habe was sie bedeuten.
wenn jmd hinweise zur aufklärung dieses falles hat, und dabei auch gleich etwas zu meinem verständnis zu objektorientierter programmierung beitragen könnte, wäre ich dafür sehr dankbar.

gruß christian

ohne mir das genau angesehen zu haben: Weißt Du, dass Memberfunktionspointer etwas anderes sind als "reine" Funktionspointer (nicht kompatibel) ?

Gruß,

Simon2.

Du kannst eine Wrapperfunktion drumrumstricken, aber insgesamt scheint mir, Du könntest virtual functions besser brauchen...
Wer übergibt eigentlich Deinem quad-Objekt den Aufrufparameter ? Kannst Du mir mal den Aufruf zeigen ?

Nur mal so ins Grobe geschrieben:

class quad {
public:
    float gauss (float);
protected:
    virtual float f1(float) { // irgenwas quad-maessiges tun 
    }
    virtual float f2(float) { // irgenwas quad-maessiges tun 
    }
};

float quad::gauss (float f) {
   // do something
   f1(f);
   // do something
   return f2(f);
}

class quad2d : public quad {
protected:
    // überladen die quad::f1 und quad::
    float f1(float) { // irgenwas quad2d-maessiges tun 
    }
    float f2(float) { // irgenwas quad2d-maessiges tun 
    }
};

int main() {
   quad q;
   q.gauss(1.2); // macht quadmaeßiges

   quad2d q2;
   q2.gauss(2.3); // macht quad2dmaeßiges
   return 0;
}

Gruß,

Simon2.

float funktion (float x){ return x; }

int main ()
{
	float a=0, b=1, result;
	int n=10;
	quad integrand(a,b,n);

	result=integrand.gauss(funktion);

	cout << result;

	return 0;
}

das original für die funktion hab ich in c-code vorliegen und da klappt es auch, hab ich schon probiert. ich wollts nun nur nochmal zu übungszwecken und der vollständigkeit halber in c++ übersetzen.

OK, jetzt weiß ich, worum es Dir geht !
Du gibst von außen eine (Art Callback-)Funktion mit, die von quad genutzt werden soll.
Braucht quad2d nun 2 Funktionen von außen und Du hofftest, mit dem Erben von quad auf Wiederverwendung ? Das scheint mir nicht besonders glücklich, weil offensichtlich für quad2d auch nicht gauss(), sondern gauss2d() aufgerufen werden sollen.

Brauchen quad(2d) überhaupt einen eigenen Status ? Mir scheint das ganze Gebiet eher wenig für einen OO-Umsetzung geeignet und denke, dass Deine bisherige Version gar nicht so schlecht ist. Aber Du könntest mit Funktionsoverloading arbeiten (wenn Du ein C++-Feature dabeihaben willst):

float gauss(float, float, int, float (*func)(float x)) { // 1-D-Implementierung }
float gauss(float, float, int, float (*func)(float x, float y))  { // 2-D-Implementierung }

float funktion(float x){ return x; }
float funktion2d(float x, float y ){ return x*y; }

int main ()
{
	float a=0, b=1, result;
	int n=10;

	result=gauss(a,b,n, funktion); // ruft 1-D-Variante auf
	result=gauss(a,b,n, funktion2d); // ruft 2-D-Variante auf

	cout << result;

	return 0;
}

Ein wenig "Eye-Candy" kannst Du sonst noch über operator-Overloading einbauen:

struct gauss {
   float operator()(float, float, int, float (*func)(float x)) { // 1-D-Implementierung }
   float operator()(float, float, int, float (*func)(float x, float y))  { // 2-D-Implementierung }
};

float funktion(float x){ cout << "funktion\n"; return x; }
float funktion2d(float x, float y ){ cout << "funktion2d\n"; return x+y; }

int main (int argc, char **argv)
{
    float a=0, b=1, result;
    int n=10;
    gauss g;

    result=g(a,b,n, funktion); // ruft 1-D-Variante auf
    cout << result << "\n";
    result=g(a,b,n, funktion2d); // ruft 2-D-Variante auf

    cout << result << "\n";
    return 0;
}

... aber wirklich weiter bringt es auch nicht (sieht aber ganz lustig aus und ist "... echt C++ig, Mann !" :D).

Gruß,

Simon2.

gruß christian

...hat mich wieder etwas tiefer in die OOP ...gebracht.

gruß christian

Naja, wohl eher nicht.
In C++ kann man eben nicht nur OO programmieren, sondern hat auch einiges in der Hand zum generischen Programmieren - und das ist bisweilen wichtiger/übersichtlicher/besser geeignet für das jeweilige Problem.
Wenn Du OOP ausprobieren willst, solltest Du Dir auch eine Aufgabe suchen, die diesen Einsatz anbietet.

Gruß,

Simon2.