Compilerfehler mit Funktionszeigern und Template

Bei mir VC2008 ergibt das keinen Fehler

int function(std::string param)
{
	return 0;
}

template<int (*T)(std::string)> int ConvertToLuaFunction(const char* parameter)
{
	std::string temp(parameter);
	return T(temp);
} 

int main(int argc, CHAR* argv[])
{
	int (*temp)(const char*) = (ConvertToLuaFunction<function>);
    ...
}

Also wahrscheinlich liegt es an dem namespace, woraufhin der compiler eine funktion nichtmehr finden kann.

appendix schrieb:

Also wahrscheinlich liegt es an dem namespace, woraufhin der compiler eine funktion nichtmehr finden kann.

Daran liegt es auch nicht. VS2005?

Der gcc meckert auch:

test.cpp: In member function ‘int Console::Register(int (*)(std::string), std::string)’:
test.cpp:20: error: ‘function’ cannot appear in a constant-expression
test.cpp:20: error: no matches converting function ‘ConvertToLuaFunction’ to type ‘int (*)(const char*)’
test.cpp:11: error: candidates are: template<int (* T)(std::string)> int ConsoleTemplate::ConvertToLuaFunction(const char*)

Ich vermute mal eine sache für C++-Standard kundige.

camper

int Console::Register(int (*function)(std::string), std::string name)
{
...
ConsoleTemplate::ConvertToLuaFunction<function>

function ist ein Funktionsparameter. Ein non-type Templateparameter muss aber ein konstanter Ausdruck sein (also bereits beim Compilieren bzw. Linken feststehen). Das kann so nicht funktionieren, sonst müsste ja während der Laufzeit Code generiert werden. Ich sehe keinen besonderen Grund, warum ConvertToLuaFunction überhaupt ein Template sein muss.

ah ok, jetzt ist klar (gcc fehlermeldung war auch etwas besser ^^)
Naja, muss ich mich nach ner anderen Lösung umschaun.

Jetzt doch noch mal ne Frage,

Ich sehe keinen besonderen Grund, warum ConvertToLuaFunction überhaupt ein Template sein muss.

Aufs template bin ich auch nur aus Ermangelungen sonstiger Ideen ausgewichen, wie könnte man es denn sonst machen?
Ich brauch irgendeine Lösung die mir meinen Funktionspointer

int (*meineFunktion)(std::string)

auf eben sowas umbiegt (und zwar generisch):

int ConvertToLuaFunction(const char* parameter)
{
        std::string temp(parameter);
        return meineFunktion(temp);
}

Simon2

Wie "generisch" muss es denn sein ?

Einerseits scheint ja meineFunktion() "selbstschreibbar" zu sein und andererseits scheint es Dir eigentlich um eine Konvertierung zu gehen (hier const char* -> std::string).

Sowas machen eigentlich Compiler und/oder ggf. Konstruktoren oder Konvertierungsoperatoren ganz gut.

Folgendes ungetestet:
In diesem Fall (char const*->std::string) brauchst Du die Funktion ConvertToLuaFunction() gar nicht, weil std::string eine implizite Konvertierung per Konstruktor erlaubt. Du kannst also direkt meineFunktion("Simon") aufrufen...

Gruß,

Simon2.

Ich breite das Beispiel glaub ich besser etwas aus:

Die prinzipielle Idee ist, ich habe eine Konsole, mit der ich Text eingeben kann.
Dieser Konsole kann man per Register(...) eine Funktion mit einem Namen angeben, die Funktion wird bei eingabe von "Name" ausgeführt, mit danach folgenden parametern, die atm als string übergeben werden Später würd ich das gerne als std::vectorstd::string machen, also schon in einzelne abschnitte geparst.
Gleichzeitig soll ein registrieren mit der Konsole aber auch bewirken, dass dieselbe Funktion für lua registriert wird, und spätestens mit std::vector gibt es sicher keine automatische passende konvertierung mehr von dem lua-string-format (glaub ist char*)
Dank luabind muss ich das ganze "nur" auf int funktion(const char*) umbiegen, aber falls ich ne Möglichkeit finden würde, das direkt auf int funktion(lua_State*) (für normales lua) umzuwandeln und zum laufen zu kriegen wärs noch besser.

Das ganze war im gezeigten code nicht ganz klar, da ich erstmal das komplizierte machen wollte (und offensichtlich daran gescheitert bin ) und danach mit dem einfachen weitermachen.

Aber abgesehen von dem konkreten Beispiel würd es mich auch prinzipiell interessieren wie man dass macht, luabind schaffts ja auch irgendwie.

Simon2

Wermo schrieb:

...spätestens mit std::vector gibt es sicher keine automatische passende konvertierung mehr von dem lua-string-format (glaub ist char*)...

Dann mach Dir doch eine:

struct luaVectorConverter {
   vector<string> data;
   luaVectorConverter(const char*);
   operator vector<string>() { return data; }
};

Das ist im Prinzip nichts Anderes als Deine Funktion ... nur eben in 2 Schritten.

Gruß,

Simon2.

Ok hast recht das ist eine idee.
Das dürfte sich ja auch auf luaState* anwenden lassen denk ich mal
Auf jedenfall vielen dank dir, camper und auch dem ersten unreg

Dann schau ich mal das ich das hinbekomm :>