Red de conocimiento informático - Material del sitio web - Cómo integrar scripts Lua en lenguaje C

Cómo integrar scripts Lua en lenguaje C

1. Llame al script Lua:

// Cree el intérprete Lua:

LuaStateOwner state;

/ Ejecute el script Lua:

state - gt;DoString("print('Hello World/n')");

// Carga el archivo de script Lua y ejecuta:

state-gt;DoFile("C: //test.lua");

// Cargue el archivo de script Lua compilado y ejecute:

state-gt; DoFile("C://test.luac") ;

2. Utilice scripts Lua para llamarse entre sí

//Establezca variables para scripts Lua

state-gt; GetGlobals().SetNumber("myvalue" , 123456);

//Obtener el valor de la variable Lua

int myvalue = state -gt GetGlobal("myvalue").GetInteger();

/ / Llamar a la función Lua

LuaFunctionlt; intgt; luaPrint = state-gt;

luaPrint("Hola mundo/n");

// Deja que Lua llame a la función del lenguaje C

int add(int a, int b){ return a b;}

state-gt; "add ", add);

state-gt; DoString("print(add(3, 4))");

Dejemos que Lua llame a la función miembro de la clase C

prueba de clase{public: int add(int a, int b){return a b;}};

Prueba de prueba

state-gt; ).RegisterDirect ("agregar", probar, agregar);

state-gt("print(add(3, 4))"); Script Lua Clase C

Este es un poco más complicado. Sin embargo, he empaquetado un archivo llamado LuaPlusHelper.h que hace el trabajo fácilmente. También es muy sencillo de implementar y puede obtener el código fuente sobre cómo lograr la misma funcionalidad utilizando LuaPlus puro.

Sin embargo, queda una limitación sin resolver: no se pueden utilizar funciones de miembros virtuales. Teniendo en cuenta que simplemente estamos llamando funciones de C en Lua, en lugar de intentar importar C perfectamente a Lua, esta limitación es perfectamente aceptable.

Además, no se puede acceder a las variables miembro de la clase directamente en Lua, se puede acceder a ellas a través de funciones miembro de la clase (como SetValue/GetValue, etc.).

//La siguiente es una clase C simple:

class Logger

{

público:

void LOGMEMBER(const char* mensaje)

{

printf("En función miembro: s/n", mensaje);

}

Logger()

{

printf("Construyendo(p) .../n", esto);

v = 10;

}

virtual ~Logger()

{

printf("Destruyendo(p).../n", esto) ;

}

Registrador(int n)

{

printf(" -- Edificio [d](p). . ./n", n, this);

}

Logger(Logger* registrador)

{

printf(" - - Construyendo [p](p).../n", logger, this);

logger-gt; LOGMEMBER(" Llamada desde constructor/n");

}

int SetValue(int val)

{

v = val;

}

int GetValue( )

{

return v;

}

público:

int v;

p>

};

//Importar script Lua:

LuaClasslt.Loggergt; (estado)

.create("Logger" ) // Definir el constructor Logger: Logger()

.createlt; ("Logger2") // Definir el constructor Logger: Logger(int)

.createlt; * gt; ("Logger3") // Definir el constructor Logger:: Logger(Logger*)

.createlt; Logger*gt ("Logger3") // Definir el constructor Logger:: Logger( Logger *)

.destroy("Free") // Definir el constructor Logger: :Logger("Free")destroy("Free") // Definir el destructor Logger: :~Logger()

.destroy("__gc") // Definir el destructor Logger::~Logger()

.def("lm", amp; Logger::LOGMEMBER) // Definición de miembro función Registrador::LOGMEMBER(const char*)

.def("SetValue", & Logger::SetValue)

.def("GetValue", & Logger:: GetValue) ;

//Usando la clase Logger (1) en Lua:

<

p>state-gt;DoString (

"l = Logger();" // Llama al constructor Logger::Logger()

"l.lm('Hola mundo 1 ');" // Llamar a la función miembro Logger: LOGMEMBER(const char*)

"l.Free();" // Llamar a la función miembro Logger: LOGMEMBER(const char*)

"l.// Llama al destructor Logger: ~Logger()

);

// Usa la clase Logger (2) en Lua:

p>

state-gt;DoString(

"m = Logger(10);" // Llama al constructor Logger::Logger (int)

"m.lm (' Hello World 2');" // Llamar a la función miembro Logger: LOGMEMBER(const char*)

"n = Logger(m);" // Llamar al constructor Logger: Logger(Logger *)

"n.lm('Hello World 3');" // Llamar a la función miembro Registrador: LOGMEMBER(const char*)

"m.SetValue(11) ;"

"print(m.GetValue());"

"n = Logger(m);" // Llama al constructor Logger::Logger(Logger*)

"n.

"m.SetValue(11;"

"print(m.GetValue());"

" m, n = nulo, nil;" //m, n será llamado como destructor por la recolección de basura de Lua

);

4. Agrupe un conjunto de funciones C en un módulo de Lua

//Como se mencionó anteriormente, para simplificar, utilicé LuaPlusHelper.h:

LuaModule(state, "mymodule")

.def ("add", add)

.def("add2", prueba, agregar);

state-gt;

"print(mymodule .add(3, 4)); "

"print( mymodule.add2(3, 4)); "

);

5. Utilice el tipo de datos de tabla de Lua

//Crear una tabla en Lua

LuaObject table = state-gt; GetGlobals().CreateTable("mytable");

table.SetInteger("m", 10 );

table.SetNumber("f", 1.99);

table.SetString("s", "Hola mundo") ;

table.SetWString("ch", L "Hola");

table.SetString(1, "Qué");