Krishty hat geschrieben:TGGC hat geschrieben:return (Zeiger - (Anzahl * GrößeVomRückgabeTyp));
Wenn du ihm schon dumm kommst, stell dich dabei nicht auch noch dumm an.
Denn bei Zeigerarithmetik ist eine Einheit
sizeof(gezeigterTyp) Bytes groß.
odenter, das ist bei deiner Allokation auch falsch,
t = new Test[ANZ]; reicht vollkommen.
Stimmt, danke. Test ist in dem Fall ja schon die "Größe".
@Lord Devlin
Ja ich hab mir die ganzen Templates angeguckt, die gefielen mir aber alle nicht. Und zwar aus dem Grunde weil dort meistens irgendwelche statischen Variablen waren in die Funktionsnamen + Zeiger geaddet wurden um diese dann von Dort Lua bekannt zu machen.
Ich bin .NET geschädigt und mir gefällrt dort die Benutzung von ADO.NET genauer die DbCommand-Klasse ziehmlich gut.
Man fügt dort lustig Parameter ein ala
Code: Alles auswählen
-- pseudo code
insert intal tablleA (feld1, feld2, feld3)
value(@feld1, @feld2, @feld3)
com.parameters.add(new Parameter("@feld1", dbsql.nvarchar))
com.parameters(0).value = "bla blubb"
com.parameters.add(new Parameter("@feld2", dbsql.int))
com.parameters(1).value = 2222
com.parameters.add(new Parameter("@feld2", dbsql.image))
com.parameters(2).value = new byte[100]
com.ExecuteNoQuery()
Auf etwas ähnliches hatte ich mich letztendlich auch schon festgelegt für die Übergabe von Parametern an Lua. Weil ich so auch gleichzeitig den Typ habe um zu bestimmen mit welcher Funktion ich was auf den Stack lege z.B. lua_pushnumber oder lua_pushstring etc. Und für die Rückgabe entsprechend auch. Aktuell kommt das noch als Parameter mit, der Plan ist aber das auch nur durch Methodenaufrufe zuzulassen.
Die Idee von Schrompf war doch gar nicht sooo verkehrt. :) Allerdings nicht als Rückgabe der Funktionen. Das Interface sieht im Prinzip nun so aus, ein bischen was muss ich noch ändern bzw. hinzufügen.
Code: Alles auswählen
class IScript {
private:
std::string fileNameValue;
std::string codeValue;
IScriptVM *scriptingVMValue;
public:
~IScript() {
}
void SetFileName(std::string fileName) { fileNameValue = fileName; }
void SetCode(std::string code) { codeValue = code; }
std::string GetFileName() { return fileNameValue; }
std::string GetCode() { return codeValue; }
// Lädt eine Script Datei
virtual void Load(std::string fileName)=0;
// Speichert eine Script Datei
virtual void Save(std::string fileName)=0;
// führt das geladene Script aus, 1 Rückgabewert
virtual bool Execute(std::vector<IScriptObject> &returnParams)=0;
// führt eine Funktion aus mit n Parametern und einem Rückgabewert
virtual bool ExecuteFunction(std::string funcName, std::vector<IScriptObject> ¶ms, std::vector<IScriptObject> &returnParams)=0;
// führt eine Funktion aus mit n Parametern und n Rückgabewerten
virtual bool ExecuteFunction(std::string funcName, std::vector<IScriptObject> ¶ms, int rtnCount, std::vector<IScriptObject> &returnParams)=0;
protected:
//std::vector<IScriptObject> parameterValue;
IScript() {
}
};
Und die benutzung sieht dann in etwa so aus
Code: Alles auswählen
CLuaVM *vm = new CLuaVM;
CLuaScript script(vm, "test.lua");
std::vector<IScriptObject> rtn;
bool ret = script.Execute(rtn);
std::vector<IScriptObject> rtn1;
std::vector<IScriptObject> a(2);
a[0].SetInt32(10);
a[1].SetInt32(20);
ret = script.ExecuteFunction("add", a, rtn1);
std::vector<IScriptObject> rtn2;
std::vector<IScriptObject> b(1);
b[0].SetString("blubbb");
ret = script.ExecuteFunction("testFunc", b, rtn2);
std::vector<IScriptObject> rtn3;
ret = script.ExecuteFunction("testRtn", rtn3, 3, rtn3);
Lua
Code: Alles auswählen
print "lalala"
function add(x,y)
return x+y
end
function testFunc(str)
print(str)
return 1
end
function testRtn()
return "blubb", 22, 34
end
Da umzu kommt noch ein Verwalter, dann kann ich auch z.B. Skript-Funktionen überladen.
