Aufruf einer Funktion aus Klasse

[enno-tyrant]

mein name ist vorhaut: ich zieh mich zurück

du willst es scheinbar nicht verstehen

[ZuK]

Trollalarm !!!

[ssm]

ok, ok, ok!
ganz locker bleiben!

#include <vector>
#include <string>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/bind/apply.hpp>

class Dummy
{
public:

	explicit Dummy(const char *name)
		:	name(name)
	{
	}

	void Callback1()
	{
		std::cout << name << "::Callback1\n";
	}

	void Callback2()
	{
		std::cout << name << "::Callback2\n";
	}

	void Callback3()
	{
		std::cout << name << "::Callback3\n";
	}

private:

	std::string name;
};

void Callback1()
{
	std::cout << "Global::Callback1\n";
}

void Callback2()
{
	std::cout << "Global::::Callback2\n";
}

void Callback3()
{
	std::cout << "Global::Callback3\n";
}

int main() 
{ 	
	//callback prototyp
	typedef boost::function<void()> callback_t;

	//vector of callback's
	typedef std::vector<callback_t> callbacks_t;

	Dummy dm1("firstDummy");
	Dummy dm2("secondDummy");

	//init vector of 9 callback's
	callbacks_t callbacks(9);

	//function pointers
	callbacks[0] = Callback1;
	callbacks[1] = Callback2;
	callbacks[2] = Callback2;

	//class member functions
	callbacks[3] = boost::bind(&Dummy::Callback1, &dm1);	
	callbacks[4] = boost::bind(&Dummy::Callback2, &dm1);
	callbacks[5] = boost::bind(&Dummy::Callback3, &dm1);

	callbacks[6] = boost::bind(&Dummy::Callback1, &dm2);	
	callbacks[7] = boost::bind(&Dummy::Callback2, &dm2);
	callbacks[8] = boost::bind(&Dummy::Callback3, &dm2);

	//call callbacks
	std::for_each(callbacks.begin(), callbacks.end(), boost::bind(&callback_t::operator(), _1));
}

:p :p :p

[PuppetMaster2k]

IcemanX schrieb:

Erkläre es mir doch, ich dachte du bist so schlau!

Eine Frage: Hast du dir folgendes hier mehrfach genanntes Kapitel 3.5 aus dem Tutorial mal angesehen? http://www.newty.de/fpt/callback.html#member Wenn ja, hast du noch Probleme mit irgendeinem Teil? Wenn ja, mit welchem?

Nur als Anmerkung: Aud der genannten Seite ist genau das was du suchst, nur auf Englisch. Du hast Beispiele als Code und sogar Kommentare und Erklärungen dazu.

[IcemanX]

wenn ich mir ansehe was du schreibst scheinst du ja selbst keine Ahnung zu haben und echt nur einen auf Klugscheißer machen.

enno-tyrant schrieb:

mein name ist vorhaut: ich zieh mich zurück

du willst es scheinbar nicht verstehen

[IcemanX]

Vielen Dank, aber wie ich es mit ner Funktion mache weis ich selbst, habe gesehen du verwendest bei Methoden was aus der Boost Lib, geht doch auch ohne????

Ausserdem ist das nicht was ich suche, ich glaube wir reden echt an ein ander vorbei!!!

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

ssm schrieb:

ok, ok, ok!
ganz locker bleiben!

#include <vector>
#include <string>
#include <boost/function.hpp>
#include <boost/bind.hpp>
#include <boost/bind/apply.hpp>

class Dummy
{
public:

	explicit Dummy(const char *name)
		:	name(name)
	{
	}

	void Callback1()
	{
		std::cout << name << "::Callback1\n";
	}

	void Callback2()
	{
		std::cout << name << "::Callback2\n";
	}

	void Callback3()
	{
		std::cout << name << "::Callback3\n";
	}

private:

	std::string name;
};

void Callback1()
{
	std::cout << "Global::Callback1\n";
}

void Callback2()
{
	std::cout << "Global::::Callback2\n";
}

void Callback3()
{
	std::cout << "Global::Callback3\n";
}

int main() 
{ 	
	//callback prototyp
	typedef boost::function<void()> callback_t;

	//vector of callback's
	typedef std::vector<callback_t> callbacks_t;
	
	Dummy dm1("firstDummy");
	Dummy dm2("secondDummy");

	//init vector of 9 callback's
	callbacks_t callbacks(9);

	//function pointers
	callbacks[0] = Callback1;
	callbacks[1] = Callback2;
	callbacks[2] = Callback2;

	//class member functions
	callbacks[3] = boost::bind(&Dummy::Callback1, &dm1);	
	callbacks[4] = boost::bind(&Dummy::Callback2, &dm1);
	callbacks[5] = boost::bind(&Dummy::Callback3, &dm1);

	callbacks[6] = boost::bind(&Dummy::Callback1, &dm2);	
	callbacks[7] = boost::bind(&Dummy::Callback2, &dm2);
	callbacks[8] = boost::bind(&Dummy::Callback3, &dm2);

	//call callbacks
	std::for_each(callbacks.begin(), callbacks.end(), boost::bind(&callback_t::operator(), _1));
}

:p :p :p

[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".