Aufruf einer Funktion aus Klasse

ssm

IcemanX schrieb:

Ich will einer Klasse eine Methode einer anderen Klasse zuweisen so das diese sie in ihren Methoden aufrufen kann.

class A
{
public:

	void callback1()
	{
	}

	void callback2()
	{
	}

	void callback3()
	{
	}
};

class B
{	
public:
	typedef void (A::*ACallback_t)();

	void setCallBack(ACallback_t callback, A *object)
	{
		this->object = object;
		this->callback = callback;
	};

	void run()
	{
		assert(object && callback);
		(object->*callback)();
	}

private:

	//callback information
	A *object;
	ACallback_t callback;

};

int main(int argc, char* argv[]) 
{ 
	A a1, a2;    

	B b;

	b.setCallBack(&A::callback1, &a1);
	b.run();

	b.setCallBack(&A::callback2, &a1);
	b.run();

	b.setCallBack(&A::callback3, &a1);
	b.run();

	b.setCallBack(&A::callback1, &a2);
	b.run();

	b.setCallBack(&A::callback2, &a2);
	b.run();

	b.setCallBack(&A::callback3, &a2);
	b.run();

}

IcemanX

Danke, nun noch eins ich möchte B so flexibel haben das ich auch eine Methode aus z.B. C ausführen kann. Unter BCB6 soll so was sehr einfach mit __closure gehen, aber wie geht es ohne oder auf anderen Compilern???

ssm schrieb:

IcemanX schrieb:

Ich will einer Klasse eine Methode einer anderen Klasse zuweisen so das diese sie in ihren Methoden aufrufen kann.

class A
{
public:

	void callback1()
	{
	}

	void callback2()
	{
	}

	void callback3()
	{
	}
};

class B
{	
public:
	typedef void (A::*ACallback_t)();
	
	void setCallBack(ACallback_t callback, A *object)
	{
		this->object = object;
		this->callback = callback;
	};
	
	void run()
	{
		assert(object && callback);
		(object->*callback)();
	}

private:

	//callback information
	A *object;
	ACallback_t callback;

};

int main(int argc, char* argv[]) 
{ 
	A a1, a2;    

	B b;

	b.setCallBack(&A::callback1, &a1);
	b.run();

	b.setCallBack(&A::callback2, &a1);
	b.run();

	b.setCallBack(&A::callback3, &a1);
	b.run();

	b.setCallBack(&A::callback1, &a2);
	b.run();

	b.setCallBack(&A::callback2, &a2);
	b.run();

	b.setCallBack(&A::callback3, &a2);
	b.run();

}

ssm

IcemanX schrieb:

Danke, nun noch eins ich möchte B so flexibel haben das ich auch eine Methode aus z.B. C ausführen kann. Unter BCB6 soll so was sehr einfach mit __closure gehen, aber wie geht es ohne oder auf anderen Compilern???

boost::function, boost::signals

virtuell Realisticer

templates duerften dir auch weiterhelfen.

mfg
v R

IcemanX

und wie?

virtuell Realisticer schrieb:

templates duerften dir auch weiterhelfen.

mfg
v R

virtuell Realisticer

IcemanX schrieb:

und wie?

virtuell Realisticer schrieb:

templates duerften dir auch weiterhelfen.

mfg
v R

Du solltest ein bisschen Eigeninitiative ergreifen. Davon merkt man leider
gar nichts.

Zwar nicht perfekt, aber so in der Art ist es machbar:

class A {
    public:
	void hello() {
	    cout<<"Hallo Welt!"<<endl;
	}
};

template<class Instance>
class B {
    typedef void (Instance::*MemFunc)();
    private:
	Instance* 	instance;
	MemFunc		memberFunction;
    public:
	template<class MemberFunction>
	B(Instance* i, MemberFunction m)
	    : instance(i), memberFunction(m)
	{}

	void callMember() {
	    (instance->*memberFunction)();
	}
};

mfg
v R

IcemanX

Eigeninitiative ? Eigentlich schon aber, ich stell mich scheinbar echt in dieser Sache bischen an.

Aber vielen Dank für deinen Post, werde es gleich mal probieren, nachdem ich diesen Code verstanden habe

Habe, da ich aus der Xbase Ecke komme noch nicht wircklich viel mit Templates gemacht :p , aber falls du magst Kannst ja noch paar Kommentare hinter den Code packen

virtuell Realisticer schrieb:

IcemanX schrieb:

und wie?

virtuell Realisticer schrieb:

templates duerften dir auch weiterhelfen.

mfg
v R

Du solltest ein bisschen Eigeninitiative ergreifen. Davon merkt man leider
gar nichts.

Zwar nicht perfekt, aber so in der Art ist es machbar:
class A {
    public:
	void hello() {
	    cout<<"Hallo Welt!"<<endl;
	}
};

template<class Instance>
class B {
    typedef void (Instance::*MemFunc)();
    private:
	Instance* 	instance;
	MemFunc		memberFunction;
    public:
	template<class MemberFunction>
	B(Instance* i, MemberFunction m)
	    : instance(i), memberFunction(m)
	{}
		
	void callMember() {
	    (instance->*memberFunction)();
	}
};
mfg
v R

virtuell Realisticer

Nabend,

kurz etwas zu templates. Wie der Name es schon sagt, handelt es sich hier um
Schablonen. Welchen Hintergrund hat das Ganze?

Nehmen wir einmal an, wir haben eine Funktion, welche 2 Werte addiert. Die
koennte z. B. so aussehen:

int add(int a, int b) {
    return (a + b);
}

Angenommen wir wollen jetzt diese Funktion auch fuer double-Werte nutzen
koennen, wuerden wir uns eine Funktion wie folgt schreiben:

double add(double a, double b) {
    return (a + b);
}

Wir sehen nun, dass wir im Grundegenommen zwei mal den gleichen Code geschrieben
haben, nur halt fuer unterschiedliche Typen. Hier kann uns das template-System
helfen:

template<typename type>
type add(type a, type b) {
    return (a + b);
}

Wir haben jetzt nur _eine_ Funktion geschrieben, welche mit unterschiedlichen
Typen aufgerufen werden kann. Dabei schaut sich der Compiler an, welcher Typ
uebergeben worden ist und 'ersetzt' "type" durch diesen Typ:

int i = add(1, 2);
//type wird ersetzt durch int

Fuer eine genauere Erklaerung schaust du dir am besten mal das Tutorial von
volkard oder Shade an. Die sind besser im Erklaeren :).

Was passiert jetzt bei unserer Klasse? Schauen wir uns das mal an:

template<class Instance>
class B {
    typedef void (Instance::*MemFunc)();
    private:
    Instance*     instance;
    MemFunc        memberFunction;
    public:
    template<class MemberFunction>
    B(Instance* i, MemberFunction m)
        : instance(i), memberFunction(m)
    {}

    void callMember() {
        (instance->*memberFunction)();
    }
};

Zunaechst einmal schauen wir uns an, wie wir eine Instanz dieser Klasse
erzeugen:

//die klassendeklaration von A steht weiter oben
A a;
B<A> b(&a, &A::nice);

Was in diesem Moment passiert ist, dass ueberall wo 'Instance' steht, dieses
durch 'A' ersetzt wird, und 'MemberFunction' durch 'A::nice', unsere
Klassendeklaration von 'B' schaut nun folgendermassen aus:

class B {
    typedef void (A::*MemFunc)();
    private:
    A*     instance;
    MemFunc        memberFunction;
    public:
    B(A* i, MemberFunction m)
        : instance(i), memberFunction(m)
    {}

    void callMember() {
        (instance->*memberFunction)();
    }
};

Das war es eigentlich auch schon, der Rest ist ja nicht weiter schwer.

Achja, ich bin nunmal sehr schlecht im erklaeren, deswegen kann es gut sein,
dass ich das ein oder andere eher schlecht ausgedrueckt habe. Hoffe das Prinzip
ist dennoch klar geworden.

mfg
v R

IcemanX

Vielen vielen DANK, außerdem ich finde du erklärst gut

Kennen etliche Entwickler die das nicht so gut können

Chris++ 0

IcemanX schrieb:

Kennen etliche Entwickler die das nicht so gut können

was heist können... ich würd eher sagen "nicht wollen".