Aufruf einer Funktion aus Klasse

[IcemanX]

O.K., macht es mir doch nicht so schwer!!!

Wenn ich Helfen kann, rede ich auch nicht dumm drum rum, schonern poste möglichst ein Beispiel Anhand des Beispiels des Fragenden.

Mir kommt es so vor als wäre es hier vielen sehr langweilig und suchen Unterhaltung.

Also ich sucht ne Lösung, vielleicht stell ich mich ein bisschen an, mag sein, aber gerade deshalb ersuche ich ja Hilfe.

MFK schrieb:

IcemanX schrieb:

Du scheinbar auch nicht!

Überleg mal, woran das liegen könnte.

[] Du hast hier schon mehrfach die entscheidende Hilfe bekommen.
[] Du zeigst eine erschreckende Lernresistenz.
[] Du hast Probleme beim sinnentnehmenden Lesen.
[] Keiner versteht dich.

Wir wollen dich alle nur ärgern.

Bitte max. 3 Antworten ankreuzen.

[enno-tyrant]

@icemanX:
verstehst du es wirklich nicht???

auch wenn du in zwanzig foren postest nützt es dir nicht, wenn du:
-> die antworten nicht verstehst
-> du die user die dir helfen wollen als schwätzer bezeichnest

mein tip:

-> umgangston beachten
-> diesen thread noch einmal von anfang an zu lesen
-> lernen zu verstehen

[MFK]

IcemanX schrieb:

O.K., macht es mir doch nicht so schwer!!!

Eigentlich machst du es dir selbst schwer. Dein Verhalten schreckt die Helfer ab.

Wenn ich Helfen kann, rede ich auch nicht dumm drum rum, schonern poste möglichst ein Beispiel Anhand des Beispiels des Fragenden.

Das ist - zumindest wie ich den Konsens in diesem Forum wahrnehme - schon mal grundsätzlich falsch. Man hilft, indem man dem Fragenden aufzeigt, wo er sich selbst informieren kann. Dabei lernt man mehr als beim bloßen Abschreiben.

Du hast von mindestens drei Leuten hier einen konkreten Link zu einem Tutorial mit guten Beispielen bekommen. Wenn du hier zeigst, dass du unwillig oder unfähig bist, diese Beispiele auf dein Problem umzusetzen, dann werden viele hier die Schlussfolgerung ziehen, dass es sich nicht lohnt, dir zu helfen.

Mir kommt es so vor als wäre es hier vielen sehr langweilig und suchen Unterhaltung.

Ist dir klar, welchen Eindruck DU hier vermittelst?

Du stellst dich als "bodenloses Loch" für Hilfe dar, weil du nur Hilfe in einer Form akzeptierst, bei der du nicht selbst denken musst. Wenn du nicht selbst denkst, lernst du nichts. Wenn du nichts lernst, stellst du immer wieder dieselben Fragen. Wenn du immer dieselben Fragen stellst, lohnt es sich nicht, dir zu helfen, weil das Zeitverschwendung wäre.

Ein letzter Versuch: In Kapitel 3.5 im Tutorial auf der hier mehrfach verlinkten Seite steht genau das, was du verstehen musst, um dein Problem zu lösen. Wenn du damit nicht weiterkommst, dann schreib genau, warum. Ansonsten wirst du hier wenig Hilfe erwarten können.

[IcemanX]

Also ich sehe schon, es gibt hier Leute die andere gerne blöd anreden, aber keine Kritik vertragen. Bitte Helft mir endlich mal. Ich würde echt gern mal mit dem Problem abschließen!

[MFK]

IcemanX schrieb:

Also ich sehe schon, es gibt hier Leute die andere gerne blöd anreden, aber keine Kritik vertragen. Bitte Helft mir endlich mal. Ich würde echt gern mal mit dem Problem abschließen!

Ich erkenne eine akute Schnallbremse. Ich geb's auf.

[IcemanX]

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

MFK schrieb:

IcemanX schrieb:

Also ich sehe schon, es gibt hier Leute die andere gerne blöd anreden, aber keine Kritik vertragen. Bitte Helft mir endlich mal. Ich würde echt gern mal mit dem Problem abschließen!

Ich erkenne eine akute Schnallbremse. Ich geb's auf.

[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