下面的这个例子是用于展示，对于一个没有向LuaBus注册的类(本例中为类GCTest2)，绑定库依然会在对象生命周期结束后，调用其析构函数。其实这算不上一个特性，只是luatinker未能正确处理这种情况，我需要证明LuaBus是不存在这种错误的。如果一个lua的绑定库没有处理这种情况，它将可能会导致严重的资源泄漏问题。
1 #include "lua/LuaFunc.h"
2
3 struct GCTest1 {
4 GCTest1() { printf("GCTest1()\n"); }
5 GCTest1(const GCTest1&) { printf("GCTest(const GCTest1&)\n"); }
6 ~GCTest1() { printf("~GCTest1()\n"); }
7 };
8 GCTest1 getGCTest1() { return GCTest1(); }
9
10 struct GCTest2 {
11 GCTest2() { printf("GCTest2()\n"); }
12 GCTest2(const GCTest2&) { printf("GCTest(const GCTest2&)\n"); }
13 ~GCTest2() { printf("~GCTest2()\n"); }
14 };
15 GCTest2 getGCTest2() { return GCTest2(); }
16
17 const char *lua_str = R"(
18 a1 = getGCTest1()
19 print(a1)
20 a1 = nil
21 a2 = getGCTest2()
22 print(a2)
23 a2 = nil
24 collectgarbage()
25 )";
26
27 int main(int argc, char **argv)
28 {
29 lua_State *L = lua::open();
30
31 lua::class_add<GCTest1>(L, "GCTest1");
32
33 lua::def(L, "getGCTest1", getGCTest1);
34 lua::def(L, "getGCTest2", getGCTest2);
35 lua::dostring(L, lua_str);
36
37 lua::close(L);
38 return 0;
39 }
程序输出：
GCTest1() GCTest(const GCTest1&) GCTest(const GCTest1&) GCTest(const GCTest1&) ~GCTest1() ~GCTest1() ~GCTest1() GCTest1: 00000000004BF218 GCTest2() GCTest(const GCTest2&) GCTest(const GCTest2&) GCTest(const GCTest2&) ~GCTest2() ~GCTest2() ~GCTest2() (_GC_META_): 00000000004BF318 ~GCTest2() ~GCTest1()
下面的例子用于演示c++的多继承，因为效率的原因，LuaBus并不直接支持多继承，但是提供了一种方式让脚本能够访问多继承的父类。
1 #include "lua/LuaFunc.h"
2
3 struct BaseA {
4 void testA() { printf("testA()\n"); }
5 };
6 struct BaseB {
7 void testB() { printf("testB()\n"); }
8 };
9 struct SubAB : public BaseA, public BaseB {
10 void testAB() { printf("testAB()\n"); }
11 };
12
13 const char *lua_str = R"(
14 ab = SubAB()
15 ab:testAB() --调用本对象的方法
16 ab:testA() -- 调用父类的方法
17 b = ab:castToBaseB() --获取本对象的其它父类
18 b:testB() --调用其它父类的方法
19 )";
20
21 int main(int argc, char **argv)
22 {
23 lua_State *L = lua::open();
24
25 lua::class_add<BaseA>(L, "BaseA");
26 lua::class_def<BaseA>(L, "testA", &BaseA::testA);
27 lua::class_add<BaseB>(L, "BaseB");
28 lua::class_def<BaseB>(L, "testB", &BaseB::testB);
29 lua::class_add<SubAB>(L, "SubAB");
30 lua::class_con<SubAB>(L, lua::constructor<SubAB>);
31 lua::class_inh<SubAB, BaseA>(L); //向脚本注册父类
32 lua::class_cast<SubAB, BaseB>(L); //向脚本注册其它父类
33 lua::class_def<SubAB>(L, "testAB", &SubAB::testAB);
34 lua::dostring(L, lua_str);
35
36 lua::close(L);
37 return 0;
38 }
程序输出：
testAB() testA() testB()
对于上面的例子，LuaBus要求向脚本注册的父类必须为子类的第一个父类，否则脚本调用回到c++层后，父类的指针将会是错误的。LuaBus提供了一种方式可以绕开这个限制，让需要被注册为父类的类继承于lua::tracker。这个特性可能在重构祖传代码时会用到，如果全新设计的代码也需要这个特性，请让我表示无语了。
1 #include "lua/LuaFunc.h"
2
3 struct BaseA {
4 void testA() { printf("testA(%p)\n", this); }
5 };
6 struct BaseB : public lua::tracer { //这个类可以在脚本中被注册为SubAB的父类，而且也只能是这个类被注册为SubAB的父类。
7 void testB() { printf("testB(%p)\n", this); }
8 };
9 struct SubAB : public BaseA, public BaseB {
10 void testAB() { printf("testAB(%p)\n", this); }
11 };
12
13 const char *lua_str = R"(
14 ab:testB() --验证c++层能够获得正确的this指针
15 )";
16
17 int main(int argc, char **argv)
18 {
19 lua_State *L = lua::open();
20
21 auto ab = SubAB();
22 ab.testAB();
23 ab.testA();
24 ab.testB();
25
26 lua::class_add<BaseA>(L, "BaseA");
27 lua::class_def<BaseA>(L, "testA", &BaseA::testA);
28 lua::class_add<BaseB>(L, "BaseB");
29 lua::class_def<BaseB>(L, "testB", &BaseB::testB);
30 lua::class_add<SubAB>(L, "SubAB");
31 lua::class_inh<SubAB, BaseB>(L);
32 lua::class_def<SubAB>(L, "testAB", &SubAB::testAB);
33 lua::set(L, "ab", &ab);
34 lua::dostring(L, lua_str);
35
36 lua::close(L);
37 return 0;
38 }
程序输出：
testAB(00000000002CF7F4) testA(00000000002CF7F4) testB(00000000002CF7F5) testB(00000000002CF7F5)
LuaBus的核心特性，处理野指针问题。让需要被注册的类继承于lua::binder即可，这样我们就可以在脚本层用is_object_alive()接口来判断当前指针是否有效，即便是在脚本层直接操纵了野指针，错误也只会发生在脚本层，而不会抛出到C++层，继而导致程序崩溃。
#include "lua/LuaBus.h"
struct PtrTest : lua::binder {
void test() { printf("test(%p)\n", this); }
};
const char *lua_str = R"(
print(pt1:is_object_alive()) --检查指针的有效性
print(pt1, pt2, pt1 == pt2) --指针的相等性测试
pt1:test() --验证对象的可用性，如果对象是野指针，脚本层就会抛出错误，但是绑定库会捕获它。
print(‘ok‘) --如果执行了这行代码，就表明脚本层没有发生任何错误。
)";
int main(int argc, char **argv)
{
lua_State *L = lua::open();
lua::class_add<PtrTest>(L, "PtrTest");
lua::class_def<PtrTest>(L, "test", &PtrTest::test);
auto pt = new PtrTest();
lua::set(L, "pt1", pt);
lua::set(L, "pt2", pt);
lua::dostring(L, lua_str); // 这次是正确的，所以一切正常。
delete pt; // 这会让脚本层产生野指针。
lua::dostring(L, lua_str); // 这次脚本层会因为野指针问题发生错误。
printf("all ok.\n"); // 验证脚本层野指针错误不会导致程序崩溃。
lua::close(L);
return 0;
}
程序输出：
true
PtrTest: 00000000006BEEE8 PtrTest: 00000000006BEEE8 true
test(00000000006B8150)
ok
false
PtrTest: 00000000006BEEE8 PtrTest: 00000000006BEEE8 true
[string "dobuffer()"]:4: userdata[00000000006BEEE8] is a nil value.
<call stack>
-> unknown : line -1 [[C] : line -1]
test() : line -1 [[C] : line -1]
unknown : line 4 [[string "dobuffer()"] : line 0]
all ok.
当某个类继承于lua::binder后，这也给我们带来了另外一个收益，那就是我们能够像写C++代码一样直接用==运算符来判断两个对象是否相等(前提是在没有重载==运算符的情况下)，而且速度非常快。从底层来讲，还有另外一个收益，那就是如果我们多次向脚本层传入同一个对象，LuaBus不会多次重复创建userdata，它会重用第一次创建的userdata，由此带来的结果自然是传递参数的速度更快了，内存占用也会更少。
最后，LuaBus还附带了一些工具类，它们让Lua与C++之间的交互尽量无缝化。小例子看不出来有啥用处，不过对于大型项目来说，这些功能几乎是必备的。如果没有这些工具类的加持，做项目时，可能就相当于不用lua绑定库，直接基于lua的c接口撸代码吧。
下面的例子简单介绍了这个工具类的作用与用法，更多功能请自行查看相关类的接口。
#include "lua/LuaFunc.h"
struct Test {
Test() : a(0) {}
Test(int a) : a(a) {}
void test() { printf("a = %d\n", a); }
int a;
};
LuaRef tmp;
void SaveTmp(LuaRef f) {
tmp = std::move(f);
}
const char *lua_str = R"(
v1, v2 = Test(), Test_int(3)
t = {}
t.print1 = function(arg)
print(‘print1‘, t, arg)
v1:test()
end
t.print2 = function(arg)
print(‘print2‘, t, arg)
v2:test()
end
f = function()
print(‘all ok.‘)
end
r = function()
print(‘ref ok.‘)
end
SaveTmp(r) -- 将变量保存到C++层
)";
int main(int argc, char **argv)
{
lua_State *L = lua::open();
// 给类注册多个构造函数
lua::class_add<Test>(L, "Test");
lua::class_con<Test>(L, lua::constructor<Test>); // 1
lua::class_con(L, "Test_int", lua::constructor<Test, int>); // 2
lua::class_def<Test>(L, "test", &Test::test);
lua::def(L, "SaveTmp", SaveTmp);
lua::dostring(L, lua_str);
// 给变量‘f‘创建一个引用，引用不会受到lua堆栈影响;
// 我们后续会对变量‘f‘进行操作，但是它也不会影响到本引用的值。
LuaRef r(L, "f");
// 调用lua table的函数
LuaFuncs tfs(L, "t");
tfs.CallMethod<void>("print1"); // 会将本对象作为第一个参数传入，类似于C++调用成员函数。
tfs.CallStaticMethod<void>("print2"); // 不会将本对象作为参数传入，类似于C++调用静态成员函数。
// 调用lua的全局函数
LuaFunc f(L, "f");
f.Call<void>();
// 将变量‘f‘置空，变量‘f‘不再有效。
lua::set(L, "f", nullptr);
// 验证变量‘f‘的状态
LuaFunc f1(L, "f");
f1.Call<void>();
// 验证引用的作用。
r.Get<LuaFunc>().Call<void>();
// 在实际应用中，我们可以把lua的临时变量长久保存在C++层，被保存的变量不会被lua回收。
// 这可能也是LuaRef最多的用法。
tmp.Get<LuaFunc>().Call<void>();
lua::close(L);
return 0;
}
程序输出：
print1 table: 00000000005BF100 table: 00000000005BF100 a = 0 print2 table: 00000000005BF100 nil a = 3 all ok. lua attempt to call global ‘f‘ (not a function) all ok. ref ok.
本例子运行完后有报错，请无视，毕竟这只是一个功能验证单元，我觉得它已经很好的完成了它的使命( ╯□╰ )
原文地址：https://www.cnblogs.com/jallyx/p/9992247.html
时间： 2024-10-14 06:33:20