 |
JLI Spieleprogrammierung
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
The Lord of Programming
Living Legend
Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
 Verfasst am: 03.10.2006, 19:59 Titel: Funktionspointer auf Methode [error C3867] |
 |
|
Hi, ich stoße hier gerade bei Funktionspointern auf ein kleines Problemchen.
Ich habe eine Methode, mit der ich Funktionen per Funktionspointer bei meiner Klasse "registrieren" will. Dafür hab ich das folgende Typedef muster definiert, bei dem die Funktion eben einen std::string als Parameter und einen als Rückgabewert hat:
| CPP: | typedef std::string (*console_func)(std::string);
//Fügt der Console eine neue Funktion hinzu,
//die ausgeführt werden kann
__forceinline void CLASSrdtdc::CAddConsoleFunction(std::string FunctionIdentifier, console_func Function)
{
//[...]
}
|
Normalerweise klappt das wunderbar. Ich definiere eine Funktion mit entsprechenden Spezifikationen...
| CPP: | std::string MyConsoleFunc(std::string Parameters)
{
return foo.bar();
} |
...und registriere diese Funktion:
| CPP: | | CLASSrdtdc::Singleton().CAddConsoleFunction("MyFunc",MyConsoleFunc); |
So, das Problem (bzw. der vorher genannte Compilerfehler) tritt auf, wenn ich jetzt eine Memberfunktion meiner Klasse selbst registrieren will:
| CPP: | CLASSrdtdc::Singleton().CAddConsoleFunction("PAUSE",CLASSrdtdc::Singleton().CPause);
//error C3867: "CLASSrdtdc::CPause": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&CLASSrdtdc::CPause", um einen Zeiger auf den Member zu erstellen.
CLASSrdtdc::Singleton().CAddConsoleFunction("PAUSE",CLASSrdtdc::CPause);
//geht genauso wenig |
Wie ichs drehe und wende, ich bekomms leider nicht hin...
Notfalls könnte ich CPause natürlich auslagern, damits wie sonst funktioniert, aber das wäre eben umständlich. Hat jemand eine Ahnung, ob man das auch hinbekommen kann, wenn man die Methode (CPause) in der Klasse behalten will?
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
 |
LordHoto
JLI'ler
Alter: 35
Anmeldedatum: 27.03.2003
Beiträge: 137
Wohnort: Gelnhausen
Medaillen: Keine
|
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 03.10.2006, 21:19 Titel: |
|
|
Hmm, danke, bin mir noch nicht sicher, ob ichs recht verstanden habe...
Ich hab mir den Code da mal angeschaut und mit meinem verglichen. Dort gibts eine Stelle, an der folgender Aufruf gemacht wird:
| CPP: | // 2. call 'DoItA' for <objA>
DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display); |
Heißt das, ich bräuchte für jede Funktion, die ich registrieren will, einen individuellen Wrapper_To_Call_X?
D.h. ich bräuchte die static Methode Wrapper_To_Call_Pause() und für jede weitere Methode, die ich auf diese Weise übergeben will, Wrapper_To_Call_AnyOtherMethod1(), Wrapper_To_Call_AnyOtherMethod2(), ...
Stimmt das so?
Das wäre dann irgendwie nicht ganz im Sinne der Flexibilität, mit der man sonst die Funktionspointer übergibt.
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
LordHoto
JLI'ler
Alter: 35
Anmeldedatum: 27.03.2003
Beiträge: 137
Wohnort: Gelnhausen
Medaillen: Keine
|
|
| Nach oben |
|
|
Kampfhund
Super JLI'ler
Alter: 42
Anmeldedatum: 20.07.2002
Beiträge: 408
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 02:44 Titel: |
|
|
| CPP: | // interface, damit subklassen den std::string operator(std::string) haben.
struct Callable
{
virtual std::string operator()(std::string str)=0;
};
// wrapper für stdcall funktionen, also normale funktionen.
struct StdCallWrapper : public Callable
{
typedef std::string (*fptr)(std::string); // so sieht der hier gekapselte funktionspointer aus
StdCallWrapper(fptr func)
:func_ptr(func)
{}
virtual std::string operator()(std::string str)
{
return (*func_ptr)(str);
}
fptr func_ptr;
};
// wrapper für klassenmethoden.
// C ist der formale-typ-parameter für die klasse
template<class C>
struct StaticCallWrapper : public Callable
{
typedef std::string (C::*fptr)(std::string);// so sieht der hier gekapselte funktionspointer aus
StaticCallWrapper(fptr func)
: func_ptr(func)
{}
virtual std::string operator()(std::string str)
{
return (*func_ptr)(str);
}
fptr func_ptr;
};
// die factory erzeugt einen der beiden Wrapper, abhängig vom funktionspointertyp
// die erste factory erzeugt einen Wrapper für normale funktionen
template<class M>
struct CallableObjectFactory
{
static Callable* create_callable(M func)
{
return new StdCallWrapper(func);
}
};
// spezialisierung der factory für "klassenmethode" als funktionspointertyp
template<class C>
struct CallableObjectFactory<std::string (C::*)(std::string)>
{
typedef std::string (C::*fptr)(std::string);
static Callable* create_callable(fptr func)
{
return new StaticCallWrapper(func);
}
};
// diese funktion registriert ein callable objekt
// zur erzeugung des korrekten callable objekts(static/stdcall-Wrapper) wird die factory verwendet
template<class M>
void RegisterFunction(M func)
{
// ist M = std::string (*func)(std::string), dann wird die erste factory benutzt
// ist dagegen M= std::string (C::*func)(std::string), dann wird die spezialisierung der factory benutzt
Callable *c = CallableObjectFactory<M>::create_callable(func);
std::cout<<(*c)("test")<<std::endl;
}
struct A
{
static std::string do_something(std::string param){ return std::string("called A::do_something")+param; }
};
//==================================================
int main()
{
// da do_something eine klassenmethode ist, wird in der factory die create_callable methode der spezialisierung aufgerufen.
// also wird ein exemplar von StaticCallWrapper zurückgegeben
RegisterFunction(A::do_something);
std::cin.get();
}
|
Müsste so direkt funktionieren (#includes fehlen nur).
Es lassen sich funktionen der art "std::string (*func)(std::string)" sowie der art "std::string (C::*func)(std::string)" registrieren, wobei C für eine beliebige klasse steht.
Das einzige was du tun müsstest wäre die RegisterFunction funktion anzupassen.
_________________
Kochen ist ein NP-schweres Optimierungsproblem. |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 14:12 Titel: |
|
|
Danke, dass ihr euch solche Mühe macht =)
@Kampfhund: Bei deiner Lösung gefällt mir das ganz und gar nicht:
| CPP: | struct A
{
static std::string do_something(std::string param){ return std::string("called A::do_something")+param; }
}; |
Wenn ich die Funktion, die ich registrieren will, static mache, dann gehts in meinem Code auch ohne dass ich sonst irgendwas verändere. Allerdings kann ich das static dort bei dieser "Art von Methode" überhaupt nicht gebrauchen(Stichwort: Zugriff auf nicht-static Member) 
Denkst/weißt du, dass/ob deine Lösung auch funktioniert, wenn sie nicht static ist?
Die Links von LordHoto schau ich mir gerade noch an. (Es gefällt mir übrigens bei beiden Vorschlägen nicht, dass man da new einsetzen muss, aber ich bin da vielleicht ein bisschen überskeptisch bzw. such nach wirklich der besten Lösung  ).
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
Kampfhund
Super JLI'ler
Alter: 42
Anmeldedatum: 20.07.2002
Beiträge: 408
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 20:46 Titel: |
|
|
| The Lord of Programming hat Folgendes geschrieben: | Bei deiner Lösung gefällt mir das ganz und gar nicht: ...
|
Oh, achso. Dh du willst, dass A::do_something auf eine Instanz von A zugreifen soll.
Wie willst du das denn haben? Willst du die Instanz, auf die A::do_something zugreifen soll bei der Registrierung festlegen? Oder willst du das irgendwie dynamisch haben, dass du also beim aufruf der methode noch einen this zeiger auf die Instanz mit übergibst?
_________________
Kochen ist ein NP-schweres Optimierungsproblem. |
|
| Nach oben |
|
|
Jonathan_Klein
Living Legend
Alter: 37
Anmeldedatum: 17.02.2003
Beiträge: 3433
Wohnort: Siegerland
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 21:21 Titel: |
|
|
Ich hab jetzt nicht alles gelesen aber:
Funktionspointer sind Zeiger auf Code.
Jede Methode existiert nur einmal, egal wie viele Objekte es gibt.
Aber je nach dem welches Objekt die Methode aufruft, muss die unterschieldiche Daten manipulieren (die der Klasse).
d.h. kannste nicht einfach einen Zeiger auf eine Methode machen, weil du dann nicht mehr wissen kannst, welches Objekt die hatte.
Genau das selbe wie bei Windows die Nachrichten Funktion in ner Klasse.
Demnach haste eigenlicht nciht so viele Möglichkeiten. Entweder muss die Methode static sein, damit sie unabhängig ist. Oder du brauchst auch noch n Zeiger auf das Objekt, um darüber dann den Funktionszeiger aufzurufen (glaube kaum das sowas in c++ geht...)
Du könntest natürlich für jede Methode eine static Methode haben, der du n zeiger übegibts, und die dann dementsprechend die Funktion des Objektes aufruft (weil du da wohl halt keine Zeiger benutzen kannst, brauchste wohl wirklich für jede Methode eine static Methode die diese Aufrufen kann).
Was besseres fällt mir jetzt nicht ein.
_________________
https://jonathank.de/games/ |
|
| Nach oben |
|
|
Fallen
JLI MVP
Alter: 40
Anmeldedatum: 08.03.2003
Beiträge: 2860
Wohnort: Münster
Medaillen: 1 (mehr...)
|
| Verfasst am: 04.10.2006, 21:35 Titel: |
|
|
Es geht, auch ohne static, würde ja Code dafür preis geben, aber die Schreibarbeit ist wirklich heftig.
Naja mal sehen.
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse." |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 21:40 Titel: |
|
|
| Kampfhund hat Folgendes geschrieben: | | The Lord of Programming hat Folgendes geschrieben: | Bei deiner Lösung gefällt mir das ganz und gar nicht: ...
|
Oh, achso. Dh du willst, dass A::do_something auf eine Instanz von A zugreifen soll.
Wie willst du das denn haben? Willst du die Instanz, auf die A::do_something zugreifen soll bei der Registrierung festlegen? Oder willst du das irgendwie dynamisch haben, dass du also beim aufruf der methode noch einen this zeiger auf die Instanz mit übergibst? |
Naja...A ist bei mir ein Singleton, d.h. es gibt theoretisch nur eine Instanz davon
Es stimmt schon, dass der Compiler eigentlich dann nicht wissen kann, welche Instanz von A er jetzt manipuliert, daher müsste irgendwoher ein Zeiger auf die Instanz selbst kommen. (Woher ist ja nicht das Problem )
Meine Frage oder das, bei dem ich noch nicht ganz durchsteige, ist eher, wie ich ihm dann sage, dass er gefälligst die Methode von einer (mir und dem Compiler) bekannten Instanz verwenden soll.
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
Kampfhund
Super JLI'ler
Alter: 42
Anmeldedatum: 20.07.2002
Beiträge: 408
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 22:23 Titel: |
|
|
| The Lord of Programming hat Folgendes geschrieben: |
Naja...A ist bei mir ein Singleton, d.h. es gibt theoretisch nur eine Instanz davon
|
Wenn A ein Singleton ist, warum darf die Methode dann nicht static sein?
Du kannst ja mit A::Instance() o.ä. dir die Singleton instanz zurück geben lassen. Auch in einer static methode.
| Zitat: |
Meine Frage oder das, bei dem ich noch nicht ganz durchsteige, ist eher, wie ich ihm dann sage, dass er gefälligst die Methode von einer (mir und dem Compiler) bekannten Instanz verwenden soll. |
Naja, das Singleton dürfte ca so aussehen:
| CPP: | class Singleton
{
static Singleton& Instance()
{
/* ungefähr so ist die methode implementiert */
static Singleton *s;
if(!s)s=new Singleton();
return *s;
}
static std::string mach_was_mit_singleton(std::string str)
{
Singleton::Instance().setze_wert( StringToInt(str) );
return "return muss sein";
}
static void setze_wert(int w)
{
Singleton::Instance().wert = w;
}
int wert;
};
|
Mit
| CPP: | Singleton::Instance()
|
bekommst du die instanz des Singletons, und zwar überall im code.
Also auch in einer static methode oder einer normalen funktion.
Du kannst dann einfach die A::mach_was_mit_singleton methode registrieren, die arbeitet immer auf der Singleton-instanz. Oder auch eine funktion wie diese:
| CPP: | std::string modifiziere_singleton(std::string str)
{
Singleton::Instance().setze_wert( StringToInt(str) );
return "return muss sein";
}
|
Wenn es das ist was du willst, dann brauchst du garkeine methoden (mit this-zeiger) registrieren, sondern kannst einfach normale funktionen registrieren.
PS: Ich vermute du hast die Methoden in deiner Singleton nicht static gemacht. Das kannst du aber wenn ich das richtig sehe, ohne bedenken machen. Wenn sie static sind kannst du sie auch in deinem bisherigen System registrieren ohne den template-schickimicki von mir (der war glaub ich sowieso überlfüssig für static-methoden).
_________________
Kochen ist ein NP-schweres Optimierungsproblem. |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 04.10.2006, 22:54 Titel: |
|
|
Da hast du auch wieder Recht.
Allerdings sind dann eben diese Set-Get-Methoden leider notwendig, weil man nicht direkt auf die Member zugreifen kann (ich weiß, ich bin pingelig  )
Static-Methoden haben denke ich ihren einzigen Sinn darin, dass sie dann offiziell zur Klasse gehören. Behandelt werden sie aber wie eine eigenständige Funktion außen, was mich dann wieder in diese Umständlichkeiten bringt. So gesehen könnte ich sie eigentlich gleich aus der Klasse raus lassen
Eine Lösung wäre es, aber ich denke mal darüber nach, inwiefern sie mir vielleicht helfen könnte =)
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
Fallen
JLI MVP
Alter: 40
Anmeldedatum: 08.03.2003
Beiträge: 2860
Wohnort: Münster
Medaillen: 1 (mehr...)
|
| Verfasst am: 04.10.2006, 23:39 Titel: |
|
|
Soa habe mal fix eine kleine implementation für dich gebastelt womit du MemberFunktionspointer nutzen kannst.
Hier mal das ganze für keine argumente und 1 Argument bei Methoden:
| CPP: | template<typename tClass, typename tReturnvalue>
class methodeHolder0
{
public:
typedef tReturnvalue (tClass::*type_Methode)();
methodeHolder0(tClass& inClass, type_Methode inMethodePtr)
: m_MethodePtr(inMethodePtr)
, m_Class(inClass)
{
}
tReturnvalue operator()()
{
if (m_MethodePtr == NULL)
throw;
return (m_Class.*m_MethodePtr)();
}
private:
type_Methode m_MethodePtr;
tClass& m_Class;
};
template<typename tClass, typename tReturnvalue, typename tArg1>
class methodeHolder1
{
public:
typedef tReturnvalue (tClass::*type_Methode)(tArg1);
methodeHolder1(tClass& inClass, type_Methode inMethodePtr)
: m_MethodePtr(inMethodePtr)
, m_Class(inClass)
{
}
tReturnvalue operator()(tArg1 inArg1)
{
if (m_MethodePtr == NULL)
throw;
return (m_Class.*m_MethodePtr)(inArg1);
}
private:
type_Methode m_MethodePtr;
tClass& m_Class;
};
|
Hier eine Testklasse:
| CPP: | class foo
{
public:
float memberFunction0()
{
return 3.14f;
}
float memberFunction1(int a)
{
return a*0.5f;
}
}; |
Und hier ein kleines Anwendungsbeispiel:
| CPP: | foo bar;
methodeHolder0 <foo, float>myMethodeHolder0(bar, &foo::memberFunction0);
float a = myMethodeHolder0();
methodeHolder1 <foo, float, int>myMethodeHolder1(bar, &foo::memberFunction1);
float b = myMethodeHolder1(10); |
Hoffe es ist ok so, mit ein bisschen Spielerei sollte dann auch solche Konstrukte möglich sein (Beachte: Nur eine Klasse wie es scheint.):
| CPP: | MethodeHolder myMethodeHolder0(bar, &foo::memberFunction0);
MethodeHolder myMethodeHolder1(bar, &foo::memberFunction1);
float a = myMethodeHolder0();
float b = myMethodeHolder1(10); |
Aber dies ist dann schon ziemlich extrem 
_________________
"I have a Core2Quad at 3.2GHz, 4GB of RAM at 1066 and an Nvidia 8800 GTS 512 on Vista64 and this game runs like ass whereas everything else I own runs like melted butter over a smokin' hot 18 year old catholic schoolgirl's arse." |
|
| Nach oben |
|
|
David
Super JLI'ler
Alter: 39
Anmeldedatum: 13.10.2005
Beiträge: 315
Medaillen: Keine
|
| Verfasst am: 05.10.2006, 06:12 Titel: |
|
|
| Kampfhund hat Folgendes geschrieben: |
| CPP: | static Singleton& Instance()
{
/* ungefähr so ist die methode implementiert */
static Singleton *s;
if(!s)s=new Singleton();
return *s;
}
|
|
Sowas ist ja ganz und garnicht schön. Wieso nicht einfach:
| CPP: | static Singleton &Instance()
{
static Singleton s;
return s;
}
|
Dein Speicher wird nämlich nichtmehr freigegeben und es ist nicht gewährleistet, auch wenn es meist so ist, dass das Betriebssystem den Speicher nach beenden des Programms freigibt. Also ist sowas durchaus ein potentielles Speicherleck und sollte tunlichst vermieden werden.
grüße |
|
| Nach oben |
|
|
Jonathan_Klein
Living Legend
Alter: 37
Anmeldedatum: 17.02.2003
Beiträge: 3433
Wohnort: Siegerland
Medaillen: Keine
|
| Verfasst am: 05.10.2006, 08:50 Titel: |
|
|
| CPP: | Singleton::~Singleton()
{
delete &(Instance());
} |
Ok, sieht kacke aus, aber es sollte ja gehen
_________________
https://jonathank.de/games/ |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de |
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Medaillen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
