好友 阅读权限 10
听众 最后登录 1970-1-1
写这篇帖子之前，我看过许多关于绑定C++对象到Lua中的文章。总结一下他们的做法，用到元表、注册表、以及一些表中函数操作的一些基础知识以及相关的细节 。 "." 与 ":" 调用表中函数时的区别呢，下面带大家一起来研究一下。[Lua] 纯文本查看 复制代码
--code 1:
--定义一张表obj
obj = {}
--下面的这行代码等价于obj["func"]=function(a,b,c)...
obj.func = function(a, b, c)
print(a, b, c)
end
print("obj:", obj)
obj.func(1,2)
obj:func(1,2)
[Shell] 纯文本查看 复制代码
obj: obj表地址
1 2 nil
obj表地址 1 2
[Lua] 纯文本查看 复制代码
--下面这种定义表中函数的当大相信大家都不陌生
obj = {}
function obj:func(a, b, c)
print(a, b, c)
end
print("obj:", obj)
obj.func(1, 2)
obj:func(1, 2)
[Shell] 纯文本查看 复制代码
obj:obj表地址
2 nil nil
1 2 nil
[Lua] 纯文本查看 复制代码
obj = {}
obj.func = function(a, b, c)
print(a, b, c)
end
mtable = {__index = obj}
otherobj = {}
setmetatable(otherobj, mtable)
print("obj:", obj)
print("mtable", mtable)
print("otherobj:", otherobj)
otherobj.func(1, 2)
otherobj:func(1, 2)
[Shell] 纯文本查看 复制代码
obj: obj表地址
mtable: mtable表地址
otherobj: otherobj表地址
1 2 nil
otherobj表地址 1 2
[C] 纯文本查看 复制代码
//filename:funct.c
#define LUA_LIB
#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>
static int _c_l_testfunc(lua_State* L)
{
unsigned char argc, index;
const char *typename;
if ((argc = lua_gettop(L)) != 0) {
printf("共传入 %d 个参数\n", argc);
for (index = 1; index <= argc; index++) {
printf(
"第 %d 个参数类型为: %s\n",
index, lua_typename(L, lua_type(L, index))
);
}
} else {
puts("0 个参数传入");
}
//清空栈
lua_settop(L, 0);
//把参数个数压入栈作为返回值
lua_pushinteger(L, argc);
return 1;
}
#if define(__cplusplus)
#define EXP_FUNC __declspec(dllexport)
#else
#define EXP_FUNC
#endif
LUA_API EXP_FUNC int luaopen_funct(lua_State* L)
{
lua_pushcfunction(L, _c_l_testfunc);
return 1;
}
[] 纯文本查看 复制代码
funct = require "funct"
--建一个表来存这个函数
obj = {}
obj.func = funct
print("\".\"调用:")
obj.func(1, "str")
print("\":\"调用:")
obj:func(1, "str")
[Shell] 纯文本查看 复制代码
"."调用：
共传入 2 个参数
第 1 个参数类型为: number
第 2 个参数类型为: string
":"调用
共传入 3 个参数
第 1 个参数类型为: table
第 2 个参数类型为: number
第 3 个参数类型为: string
[C++] 纯文本查看 复制代码
//filename: lbind.cpp
#include <iostream>
#include <string>
#define LUA_LIB
#include <lua.hpp>
//起名字时尽量起一个独一无二的名字，可以用UUID字符串作为名字
const char* ClassName = "{1111-2222-3333-4444}";
class MyClass {
public:
MyClass(const char* name, int a, int b):na(a),nb(b){
this->name = new std::string(name);
std::cout<< "Hello, I'm " << *(this->name) << ". MyClass was Created!" << std::endl;
};
~MyClass(void){
std::cout<< "Goodbye, I'm " << *(this->name) << ". MyClass was Destroyed!" << std::endl;
delete this->name;
};
int SumThem(void) {
return (this->na + this->nb);
}
void SetNumA(int a) {
this->na = a;
}
void SetNumB(int b) {
this->nb = b;
}
int GetNumA(void) {
return this->na;
}
int GetNumB(void) {
return this->nb;
}
//这里只是测试，暴露死私有成员是不安全的
void GetName(std::string **name) {
*name = (this->name);
}
void SetName(const char* name) {
delete this->name;
this->name = new std::string(name);
}
private:
int na, nb;
std::string* name;
};
//检查参数
static bool c_CheckPointer(lua_State* L, MyClass** po)
{
MyClass** pobj;
//检查是否有参数
if (lua_gettop(L) == 0) {
luaL_error(L, "参数错误！\n请用\":\"方式调用!");
return false;
}
//检查第一个参数是否是userdata
if (lua_type(L, 1) != LUA_TUSERDATA) {
luaL_error(L, "调用方式错误！\n请用\":\"方式调用!");
return false;
}
//取出userdata
pobj = (MyClass**)lua_touserdata(L, 1);
//判断用来装对象指针的那块内存是否已经被回收
if (pobj != NULL) {
//判断对象是否已经被销毁
if ((*po = *pobj) == NULL)
luaL_error(L, "对象已销毁！");
return true;
} else {
luaL_error(L, "内存已经被回收！");
return false;
}
}
static int c_SumThem(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
lua_pushinteger(L, obj->SumThem());
return 1;
}
static int c_SetNumA(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
//从第二个参数开始为第一个参数
//因为":"调用用掉第一个参数了，显示调用的参数的位置都往后挪一位
int a = luaL_checkinteger(L, 2);
obj->SetNumA(a);
return 0;
}
static int c_SetNumB(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
//从第二个参数开始为第一个参数
//因为":"调用用掉第一个参数了，显示调用的参数的位置都往后挪一位
int b = luaL_checkinteger(L, 2);
obj->SetNumB(b);
return 0;
}
static int c_GetNumA(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
int a = obj->GetNumA();
lua_pushinteger(L, a);
return 1;
}
static int c_GetNumB(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
int b = obj->GetNumB();
lua_pushinteger(L, b);
return 1;
}
static int c_GetName(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
std::string *name;
obj->GetName(&name);
lua_pushstring(L, name->c_str());
return 1;
}
static int c_SetName(lua_State* L)
{
MyClass* obj;
if (c_CheckPointer(L, &obj) == false)
return 0; //返回nil
const char* name = luaL_checkstring(L, 2);
obj->SetName(name);
return 0;
}
//主动回收
static int c_destroy(lua_State* L)
{
MyClass** pobj;
if (lua_gettop(L) == 0) {
luaL_error(L, "此函数无参数！请用\":\"方式调用!");
} else {
if (lua_type(L, 1) == LUA_TUSERDATA) {
pobj = (MyClass**)lua_touserdata(L, 1);
if (pobj != NULL) {
if (*pobj != NULL) {
delete *pobj;
*pobj = NULL;
} else {
luaL_error(L, "对象已销毁！");
}
} else {
luaL_error(L, "内存已经被回收！");
}
}
}
return 0;
}
//靠__gc 被动回收
static int c_gc_destroy(lua_State* L)
{
//肯定会有参数传进来
//直接对类型进行判断
if (lua_type(L, 1) == LUA_TUSERDATA)
return c_destroy(L);
}
//C函数表
const struct luaL_Reg methods[] = {
{"SumThem", c_SumThem},
{"SetNumA", c_SetNumA},
{"SetNumB", c_SetNumB},
{"GetNumA", c_GetNumA},
{"GetNumB", c_GetNumB},
{"GetName", c_GetName},
{"SetName", c_SetName},
{"destroy", c_destroy},
{NULL, NULL}
};
static int c_CreateMyClassObject(lua_State* L)
{
//需要一个二级指针，指向一个用来装对象指针的内存
MyClass** pobj;
//参数检测
if (lua_gettop(L) != 3)
return 0; //返回nil
const char* name = luaL_checkstring(L, 1); //第一个实参
int a = luaL_checkinteger(L, 2); //第二个实参
int b = luaL_checkinteger(L, 3); //第三个实参
//清空当前栈
lua_settop(L, 0);
pobj = (MyClass**)lua_newuserdata(L, sizeof(MyClass**));
if (pobj == NULL)
return 0; //空间分配错误
try {
*pobj = new MyClass(name, a, b);
} catch (...) {return 0;}
//userdata在栈中的位置
int userdata_index = lua_gettop(L);
//深入了解过C++的朋友都知道，不管创建多少个对象，成员函数只有一份
//我们就创建一张函数表，可以存进Lua注册表里，也可以存放到Lua全局表里
//如果我们要把函数表存放到注册表中，我们可以用luaL_newmetatable
//如果我们要把函数表存放到全局表中，我们可以用lua_setglobal
//创建函数表，这个函数表可以只有一份，太多会浪费内存
//下面就以存进_G表为例
//先判断现在的全局表里是否已经存在张函数表
lua_getglobal(L, ClassName);
//如果是栈顶的值是nil，则不存在，我们得创建新表
if (lua_type(L, -1) == LUA_TNIL) {
//接着再创建函数表，直接用lua给我们的函数直接创建一张函数表
luaL_newlib(L, methods);
//创建一个表副本，因为等会把表写入_G表中后会被弹出，后面还得用到
lua_pushvalue(L, -1);
//写入_G表中
lua_setglobal(L, ClassName);
}
//methods表在栈中的位置
int methods_index = lua_gettop(L);
//我们还需要一张元表，这张元表是存在注册表中的
//先判断，如果不存在就创建，存在就将这样表压栈
//名字可以和_G表中的表同名，因为是存在注册表中的
if (luaL_newmetatable(L, ClassName) != 0) {
if (luaL_getmetatable(L, ClassName) == 0) //获取出错
return 1; //nil被压栈，直接返回
}
//元表在栈中的索引
int mtable_index = lua_gettop(L);
//设置元表的__index
lua_pushliteral(L, "__index");
//先拷贝一份methods表
lua_pushvalue(L, methods_index);
//添加到元表中
lua_settable(L, mtable_index);
//我们还可以保护好元表（隐藏起来）
lua_pushliteral(L, "__metatable");
lua_pushstring(L, "就不让你知道，嘤嘤嘤~~~");
lua_settable(L, mtable_index);
//接下来就是垃圾回收问题了
//我们得考虑的是：垃圾回收的控制权在谁的手里。
//我们将两种都加入到我们的表中
//被动回收
lua_pushliteral(L, "__gc");
lua_pushcfunction(L, c_gc_destroy);
lua_settable(L, mtable_index);
//设置弱引用
lua_pushliteral(L, "__mode");
lua_pushliteral(L, "kv");
lua_settable(L, mtable_index);
//最后，把元表与userdata绑定
lua_pushvalue(L, mtable_index);
lua_setmetatable(L, userdata_index);
//降低栈，让userdata位于栈顶
lua_settop(L, userdata_index);
return 1;
}
//这里就是把C函数导出到Lua中的接口
extern "C" __declspec(dllexport) int luaopen_lbind(lua_State* L)
{
//我们可以选择把函数名写到全局表里
//就可以保证函数名和导入名字一样
//也可以返回一个函数，由Lua来处理这个函数的存留
//我们这里就直接返回这个构造函数吧
lua_pushcfunction(L, c_CreateMyClassObject);
return 1;
}
[] 纯文本查看 复制代码
--导入CFunction
--因为是通过返回CFunctoin的形式，名字随便起
MyClass = require "lbind"
--创建对象
o1 = MyClass("xxxx", 1, 2)
o2 = MyClass("yyyy", 3, 4)
o3 = MyClass("zzzz", 5, 6)
print("o1: ", o1)
print("o2: ", o2)
print("o3: ", o3)
--测试一下获取元表，我们设置了__metatable，所以不会得到真正的元表
print("__metatable: ", getmetatable(o3))
--当我们直接打印函数返回值时是不会输出nil的
--我们得主动的用":"方式去调用，不然就会报错
print("call o1 method:")
print("o1:GetName ->", o1:GetName())
print("o1:GetNumB -> ", o1:GetNumB())
print("o1:SetNumB -> ", o1:SetNumB(666))
print("o1:GetNumB -> ", o1:GetNumB())
print("o1:GetNumA -> ", o1:GetNumA())
print("o1:SumThem -> ", o1:SumThem())
print("call o2 method:")
print("o2:GetName -> ", o2:GetName())
print("o2:SetName -> ", o2:SetName("嘤嘤嘤"))
print("o2:GetName -> ", o2:GetName())
print("o2:GetNumA -> ", o2:GetNumA())
print("o2:GetNumB -> ", o2:GetNumB())
print("o2:SumThem -> ", o2:SumThem())
--我们有两种方式去销毁对象
--第一种是主动去销毁；第二种是让垃圾回收机制回收
print("主动销毁:")
o2:destroy()
print("在创建一个类用来测试：")
testobj = MyClass("Test", 2333, 666)
testobj = nil --将其设为nil
collectgarbage() --等待的话太久了，我们直接强制启动垃圾回收也一样
print("call o3 method:")
print("o3:GetName -> ", o3:GetName())
print("o3:GetNumA -> ", o3:GetNumA())
print("o3:GetNumB -> ", o3:GetNumB())
print("o3:SumThem -> ", o3:SumThem())
print("Lua脚本执行完会自动处理完所有的对象:")
[Shell] 纯文本查看 复制代码
Hello, I'm xxxx. MyClass was Created!
Hello, I'm yyyy. MyClass was Created!
Hello, I'm zzzz. MyClass was Created!
o1: {1111-2222-3333-4444}: 003FECD0
o2: {1111-2222-3333-4444}: 003FEDC0
o3: {1111-2222-3333-4444}: 003FEE10
__metatable: 就不让你知道，嘤嘤嘤~~~
call o1 method:
o1:GetName -> xxxx
o1:GetNumB -> 2
o1:SetNumB ->
o1:GetNumB -> 666
o1:GetNumA -> 1
o1:SumThem -> 667
call o2 method:
o2:GetName -> yyyy
o2:SetName ->
o2:GetName -> 嘤嘤嘤
o2:GetNumA -> 3
o2:GetNumB -> 4
o2:SumThem -> 7
主动销毁:
Goodbye, I'm 嘤嘤嘤. MyClass was Destroyed!
在创建一个类用来测试：
Hello, I'm Test. MyClass was Created!
Goodbye, I'm Test. MyClass was Destroyed!
call o3 method:
o3:GetName -> zzzz
o3:GetNumA -> 5
o3:GetNumB -> 6
o3:SumThem -> 11
Lua脚本执行完会自动处理完所有的对象:
Goodbye, I'm zzzz. MyClass was Destroyed!
Goodbye, I'm xxxx. MyClass was Destroyed!
[C++] 纯文本查看 复制代码
//filename: lbindthunk.cpp
#include <iostream>
#include <string>
#define LUA_LIB
#include <lua.hpp>
//声明
class MyClass;
typedef int (MyClass::*cmtype)(lua_State* L);
#define METHOD(CLASS, METHODNAME) {#METHODNAME, &CLASS::METHODNAME}
//定义
class MyClass {
public:
//用一个结构体把类成员函数名，以及成员函数指针放到结构体里
//等会把结构体作为upvalue绑定到不同name的thunk
//其实都是同一个函数thunk啦，只不过在Lua中被赋予了不同的upvalue
struct methods{
const char* name;
cmtype method;
};
static char ClassName[0x20];
public:
static int Create(lua_State* L) {
MyClass** pobj;
//如果下次想要再添加函数在这里修改就好了
static struct MyClass::methods methodtable[] = {
METHOD(MyClass, SumThem),
METHOD(MyClass, SetNumA),
METHOD(MyClass, SetNumB),
METHOD(MyClass, GetNumA),
METHOD(MyClass, GetNumB),
METHOD(MyClass, SetName),
METHOD(MyClass, GetName),
{NULL, NULL}
};
//参数检测
if (lua_gettop(L) != 3)
return 0; //返回nil
const char* name = luaL_checkstring(L, 1); //第一个实参
int a = luaL_checkinteger(L, 2); //第二个实参
int b = luaL_checkinteger(L, 3); //第三个实参
//清空当前栈
lua_settop(L, 0);
pobj = (MyClass**)lua_newuserdata(L, sizeof(MyClass**));
if (pobj == NULL)
return 0; //空间分配错误
try {
*pobj = new MyClass(name, a, b);
} catch (...) {return 0;}
//userdata在栈中的位置
int userdata_index = lua_gettop(L);
//这回我们也来自己实现一手函数表
//我们把对应的成员函数地址存进一个结构体数组里
//把结构体作为上值，当我们在lua中调用时，就可以通过thunk调用到相应的函数啦
//老规矩，先判断全局表中是否已经存在这张函数表
lua_getglobal(L, MyClass::ClassName);
int method_index = lua_gettop(L);
if (lua_type(L, method_index) == LUA_TNIL) {
//创建一张用来存放函数的表
lua_newtable(L);
//函数表在栈中的位置
method_index = lua_gettop(L);
//这里和官方的例子的做法一模一样
for (struct MyClass::methods* p = ( MyClass::methods*)methodtable;
(p->name) && (p->method); p++) {
lua_pushstring(L, p->name);
lua_pushlightuserdata(L, p);
lua_pushcclosure(L, MyClass::Thunk, 1);
lua_settable(L, method_index);
}
//主动回收
lua_pushliteral(L, "destroy");
lua_pushcfunction(L, MyClass::destroy);
lua_settable(L, method_index);
}
if (luaL_newmetatable(L, ClassName) != 0) {
if (luaL_getmetatable(L, ClassName) == 0) //获取出错
return 1; //nil被压栈，直接返回
}
//元表在栈中的索引
int mtable_index = lua_gettop(L);
//下面的步骤就跟上面的之前的例子中一模一样
//设置元表的__index
lua_pushliteral(L, "__index");
//先拷贝一份methods表
lua_pushvalue(L, method_index);
//添加到元表中
lua_settable(L, mtable_index);
//我们还可以保护好元表（隐藏起来）
lua_pushliteral(L, "__metatable");
lua_pushstring(L, "就不让你知道，嘤嘤嘤~~~");
lua_settable(L, mtable_index);
//接下来就是垃圾回收问题了
//我们得考虑的是：垃圾回收的控制权在谁的手里。
//我们将两种都加入到我们的表中
//被动回收
lua_pushliteral(L, "__gc");
lua_pushcfunction(L, MyClass::destroy);
lua_settable(L, mtable_index);
//设置弱引用
lua_pushliteral(L, "__mode");
lua_pushliteral(L, "kv");
lua_settable(L, mtable_index);
//最后，把元表与userdata绑定
lua_pushvalue(L, mtable_index);
lua_setmetatable(L, userdata_index);
//降低栈，让userdata位于栈顶
lua_settop(L, userdata_index);
return 1;
}
//这是调用函数的核心
static int Thunk(lua_State* L) {
MyClass* o;
//确保万无一失
if (MyClass::CheckPointer(L, &o) == false)
return 0;
struct MyClass::methods* p = (MyClass::methods*)lua_touserdata(L, lua_upvalueindex(1));
if (!p) {
luaL_error(L, "函数表出错！");
return 0;
}
//把栈底的userdata删了，因为return那调用的函数中可以使用this指针
lua_remove(L, 1);
//调用成员函数
return (o->*(p->method))(L);
}
static bool CheckPointer(lua_State* L, MyClass** po)
{
MyClass** pobj;
//检查是否有参数
if (lua_gettop(L) == 0) {
luaL_error(L, "参数错误！\n请用\":\"方式调用!");
return false;
}
//检查第一个参数是否是userdata
if (lua_type(L, 1) != LUA_TUSERDATA) {
luaL_error(L, "调用方式错误！\n请用\":\"方式调用!");
return false;
}
//取出userdata
pobj = (MyClass**)lua_touserdata(L, 1);
//判断用来装对象指针的那块内存是否已经被回收
if (pobj != NULL) {
//判断对象是否已经被销毁
if ((*po = *pobj) == NULL)
luaL_error(L, "对象已销毁！");
return true;
} else {
luaL_error(L, "内存已经被回收！");
return false;
}
}
static int destroy(lua_State* L) {
MyClass** pobj;
if (lua_gettop(L) == 0) {
luaL_error(L, "此函数无参数！请用\":\"方式调用!");
} else {
if (lua_type(L, 1) == LUA_TUSERDATA) {
pobj = (MyClass**)lua_touserdata(L, 1);
if (pobj != NULL) {
if (*pobj != NULL) {
delete *pobj;
*pobj = NULL;
} else {
luaL_error(L, "对象已销毁！");
}
} else {
luaL_error(L, "内存已经被回收！");
}
}
}
return 0;
}
~MyClass(void){
std::cout<< "Goodbye, I'm " << *(this->name) << ". MyClass was Destroyed!" << std::endl;
delete this->name;
};
//////////////////////////////////////////////////////
//下面这些类成员方法直接绑定到Lua中
int SumThem(lua_State* L) {
lua_pushinteger(L, this->na + this->nb);
return 1;
}
int SetNumA(lua_State* L) {
this->na = luaL_checkinteger(L, 1);
return 0;
}
int SetNumB(lua_State* L) {
this->nb = luaL_checkinteger(L, 1);
return 0;
}
int GetNumA(lua_State* L) {
lua_pushinteger(L, this->na);
return 1;
}
int GetNumB(lua_State* L) {
lua_pushinteger(L, this->nb);
return 1;
}
int GetName(lua_State* L) {
lua_pushstring(L, this->name->c_str());
return 1;
}
int SetName(lua_State* L) {
const char* name = luaL_checkstring(L, 1);
delete this->name;
this->name = new std::string(name);
return 1;
}
////////////////////////////////////////////////////////
private:
int na, nb;
std::string* name;
MyClass(const char* name, int a, int b):na(a),nb(b){
this->name = new std::string(name);
std::cout<< "Hello, I'm " << *(this->name) << ". MyClass was Created!" << std::endl;
};
MyClass(void){}
};
char MyClass::ClassName[0x20] = {"{1111-2222-3333-4444}"};
extern "C" __declspec(dllexport) int luaopen_lbindthunk(lua_State* L)
{
//直接把MyClass中的静态成员函数Create作为CFunction返回
lua_pushcfunction(L, MyClass::Create);
return 1;
}
[Shell] 纯文本查看 复制代码
Hello, I'm xxxx. MyClass was Created!
Hello, I'm yyyy. MyClass was Created!
Hello, I'm zzzz. MyClass was Created!
o1: {1111-2222-3333-4444}: 0082A288
o2: {1111-2222-3333-4444}: 0082DA50
o3: {1111-2222-3333-4444}: 0082DBB8
__metatable: 就不让你知道，嘤嘤嘤~~~
call o1 method:
o1:GetName -> xxxx
o1:GetNumB -> 2
o1:SetNumB ->
o1:GetNumB -> 666
o1:GetNumA -> 1
o1:SumThem -> 667
call o2 method:
o2:GetName -> yyyy
o2:SetName -> 嘤嘤嘤
o2:GetName -> 嘤嘤嘤
o2:GetNumA -> 3
o2:GetNumB -> 4
o2:SumThem -> 7
主动销毁:
Goodbye, I'm 嘤嘤嘤. MyClass was Destroye
在创建一个类用来测试：
Hello, I'm Test. MyClass was Created!
Goodbye, I'm Test. MyClass was Destroyed!
call o3 method:
o3:GetName -> zzzz
o3:GetNumA -> 5
o3:GetNumB -> 6
o3:SumThem -> 11
Lua脚本执行完会自动处理完所有的对象:
Goodbye, I'm zzzz. MyClass was Destroyed!
Goodbye, I'm xxxx. MyClass was Destroyed!
BindLua.rar
(32.73 KB, 下载次数: 5)
小甲鱼：Change the World by Programming.
查看全部评分
发表于 2018-12-5 12:35
