error C2440: 'initializing' : cannot convert from 'int (__cdecl *)(const char *)' to 'int (__cdecl *)(const char *)'
1> None of the functions with this name in scope match the target type

//console.cpp (gekürzt)
int Console::Register(int (*function)(std::string), std::string name)
{
	int (*temp)(const char*) = (ConsoleTemplate::ConvertToLuaFunction<function>); //hier ist der compilerfehler
		RegisterWithLua(temp);
	}
	return 0;	
}

//console.h (gekürzt)
class Console {
private:
	int RegisterWithLua(int (*function)(const char*));
public:
	int Register(int (*function)(std::string), std::string name);
};

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

Was zum Teufel? "cannot convert from 'int (__cdecl *)(const char *)' to 'int (__cdecl *)(const char *)'" ?
Ich bin mir ja sicher, das ich irgendwas mit dem template verhaun hab, aber was das genau sein soll, da hab ich bei dieser Fehlermeldung wirklich keine Ahnung.

int (*temp)(const char*) = (ConsoleTemplate::ConvertToLuaFunction<function>); //hier ist der compilerfehler
        RegisterWithLua(temp);
    }
    return 0;

muss

int (*temp)(const char*) = (ConsoleTemplate::ConvertToLuaFunction<function>); //hier ist der compilerfehler
RegisterWithLua(temp);
return 0;

sein

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.

Daran liegt es auch nicht. VS2005?

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.

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.

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);
}

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.

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.

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

Dann schau ich mal das ich das hinbekomm :>