Lua封装&C++实践(一)——Lua和C/C++的基本交互

Lua 是一个小巧的脚本语言,它本身就是作为嵌入脚本而设计的,在目前所有脚本引擎中,Lua的速度是最快的。而且它的解释器非常轻量,其解释器不过200k(不同版本可能略有差异)。

Lua项目包含许多技术点,花些时间研究可以有不少收获,学到很多东西。包括与宿主语言的交互、内存管理、虚拟机实现、协程、闭包、异常捕获机制等等,后续有时间慢慢研究下。

如题所示,本系列主要记录Lua封装相关笔记,主要是记录C++11的相关学习与实践。Lua相关原理并不懂,在笔记中也暂不提,后续有时间深入学习Lua时,再做相关笔记。

Lua与C/C++交互基础

Lua和C/C++语言通信的主要方法是通过Lua先进后出(FILO)的虚拟栈。在Lua中,Lua堆栈就是一个struct,堆栈索引的方式可是是正数也可以是负数,区别是:正数索引1永远表示栈底,负数索引-1永远表示栈顶。

Lua的使用,依赖于Lua的状态机lua_State,Lua的堆栈也存在于状态机中。这里的状态机,类似与Java的jvm,是解析、执行lua的基石。无论是Lua调用C/C++,还是C/C++调用Lua,都是A把数据压栈、B把数据从栈取出来,这里的数据可能是元数据也可能是一个地址。

在做Lua与C/C++交互时,方法、参数、返回值都需要压入堆栈。在后面会用例子来说明。

C/C++调用Lua

C/C++调用Lua相对来说比较简单,需要注意的是,当使用C++时,在引入Lua头文件时候,需要使用#include "lua.hpp",在lua.hpp内容如下,使用了extern c来告知编译器,以C Linkage方式编译,也就是抑制C++的name mangling机制。否则会编译出错。

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

然后我们需要有一个Lua文件:

function helloAdd(num1, num2)
    return (num1 + num2)
end

在C/C++中调用Lua的步骤如下:

void testCCallLua(){
    int ret;
    //第一步:创建一个Lua的状态机
    lua_State * l = luaL_newstate();
    //第二步:打开需要使用的库。虽然例子没用到,这个还是全部打开。还有另外的方法打开指定的库luaopen_xxx(l)
    luaL_openlibs(l);
    //第三步:加载(执行)指定的lua文件,lua没有main函数。函数、table、全局变量什么的都到栈中了,函数外面的程序直接就执行了
    ret = luaL_dofile(l, "../res/test1.lua");
    std::cout<<"doFile : "<< ret<< std::endl;
    //第四步:获取指定的lua函数,这一步会把第二个参数压入堆栈中
    ret = lua_getglobal(l, "helloAdd");
    std::cout<<"getFunction : "<< ret<< std::endl;
    //第五步:把函数需要的参数压入到栈中
    lua_pushnumber(l, 10);
    lua_pushnumber(l, 5);
    //第六步:调用函数前面压入到栈中的函数,第二个参数为被调函数的参数个数,第三个参数为返回个数,因为lua是支持多个返回值的
    lua_call(l, 2, 1);
    //第六步:调用函数后,结果被放在栈顶,按照类型去取结果。多个返回值的时候,需要注意索引值,取完结果后弹出数据。结果也可以每取一个调用lua_pop弹出被取出的结果
    double iResult = lua_tonumber(l, -1);
    std::cout<<"result:" << iResult << std::endl;
    lua_pop(l,1);
    //最后一步: 使用完后,要注意关闭释放状态机
    lua_close(l);
    l = nullptr;
}

Lua调用C

Lua调用C可以通过注册库、然后在lua中加载库的方式来调用,也可以通过直接函数压栈的方式来调用。在这里记录的为函数压栈的方式。

这里,我们先准备好要被调用的C函数。

// 这是原来的C函数
double cFuncAdd(double a, double b){
    return a+b;
}

// C函数被调用,需要符合Lua的规则,所以需要做一个转调
// 返回值表示函数返回值的个数
int luaBindCFuncAdd(lua_State * l){
    double a = luaL_checknumber(l, 1);
    double b = luaL_checknumber(l, 2);
    lua_pushnumber(l, cFuncAdd(a, b));
    return 1;
}

C函数被调用,需要符合lua的规则。前面提到过,C和Lua的互调都是通过栈来完成的,Lua解释器在解释Lua中调用的函数时,也是通过函数名、函数参数等去和堆栈做交互的。所以在上面luaBindCFuncAdd中,实际执行也是从堆栈中依次取出两个参数,然后调用C函数执行,并把结果压入栈中,然后lua从栈中得到结果。

Lua只是嵌入脚本,它的执行依赖宿主程序,所以我们还是需要写C代码来执行lua,并且上面我们只是准备好了C函数,但是这个C函数并没有通过Lua状态机和lua建立联系。

void testLuaCallC(){
    std::cout << "start test Lua Call C --------------------- " << std::endl;
    //前面步骤一样,创建状态机,打开lua库
    lua_State * l = luaL_newstate();
    luaL_openlibs(l);
    //把C函数压入栈中,第二个参数只接受输入参数是lua_State,输出位int值的函数。
    lua_pushcfunction(l,luaBindCFuncAdd);
    //对应C调用lua方法的那个getglobal,这里是把栈顶的函数取个名字
    lua_setglobal(l,"cFuncAdd");
    //然后执行lua程序,这里直接写了一串lua代码,输出函数执行结果
    int ret = luaL_dostring(l,"print('cFuncAdd ret :', cFuncAdd(98,9))");
    std::cout<<"doFile:" << ret << std::endl;
    lua_close(l);
}

C和Lua的相互调用这样其实就比较好理解了,把C的函数放入堆栈中被Lua调用,还是lua中的函数被lua调用,至少从表现上来说,并没有区别,可能都是执行前把方法压入了堆栈,执行时,根据名字,找到对于的函数放到栈顶,然后压入参数,执行函数,再从栈顶得到返回的结果。

Lua调用C++

这个就相对麻烦点了,上面的Lua调用C的时候,我们知道lua_pushcfunction只能传入固定格式的C函数。要让Lua可以调用C++,而且按照我们在C++中使用类的方式来进行调用,我们就需要对C++代码做更多的处理去满足lua的要求了。实际上,巧用Lua的userdata可以满足我们的各种需求。

在这里的示例中,实际上是通过userdata+metatable来实现C++到Lua的映射,把C++类映射为Lua中的table。
其中metatable在Lua中,允许我们改变table的行为。在Lua中,每个行为关联了对应的元方法。常见的元方法有:

__index //通过table获取table的属性及方法时会调用此方法
__gc	//table被回收时,会调用此方法
__newindex //对表更新,和__index类似,__index是访问旧值,对不存在的索引增加值时会调用此方法
//以下这些都对应着表的运算符,可以看做是用于运算符的重载。
__add、__sub、__mul、__div、__mod、__unm、__concat、__eq、__lt、__le
__call //在 Lua 调用一个值时调用
__tostring //用于修改表的输出行为,相当于java中的tostring方法重载

给一个table设置元表(metatable)后,在对table执行某个操作时,就会按照元表的定义来执行。比如,一个table设置了元表,元表中实现了__index元方法,则table.xxx和table:xxx都会先执行__index方法,通过__index决定应该做什么。

我们在后面就是用Lua的这个特性,来实现对C++的调用。

首先,写下我们最终期望的Lua代码:

-- 我们创建了一个类,然后去使用它的方法,并且也能访问它的属性
operate = OperateCpp()
print("OperateCpp:multiply ret : ", operate:multiply(5.0,12.0))
print("OperateCpp.errorCode is :", operate.errorCode)

准备C++的类,和转调用的C函数:


class OperateCpp{
private:
    double x{};
    double y{};
    int type{};
public:

    int errorCode = -1;

    OperateCpp() = default;
    ~OperateCpp(){
        std::cout<<"OperateCpp destroy"<<std::endl;
    }

    double multiply(double x, double y){
        return x * y;
    }
};

//构造函数的转调函数
static int LuaCreateOperateCpp(lua_State * l){
	//Lua状态机是不知道C++类这个东西的,但是Lua中有userdata来支持扩展
	//所以,在这里,我们先指定大小,获取一块内存,并放进堆栈中,作为一个userdata。这块内存,宿主程序是可以直接使用的
    auto ** pData = (OperateCpp**)lua_newuserdata(l, sizeof(OperateCpp*));
    //我们把userdata中的内容,赋值为一个C++类实例的指针
    *pData = new OperateCpp();
    //然后我们去获取一个名为OperateCpp元表,然后放到栈顶。这个名字可以随意,但是要确保这个元表是存在的。
    //在关联的时候,我们会去创建一个这样的元表,确保在这里可以获取到。
    luaL_getmetatable(l, "OperateCpp");
    //把元表和指定位置的userdata关联起来,这里是-2,就是上面new出来的,-1被上面指定的元表占据了
    lua_setmetatable(l, -2);
    return 1;
}

//销毁对象
static int LuaDestroyOperateCpp(lua_State* L){
    // 释放对象
    delete *(OperateCpp**)lua_topointer(L, 1);
    return 0;
}

//函数的转调
static int LuaFuncMultiply(lua_State * l){
    auto * oc = *(OperateCpp **)lua_topointer(l, 1);
    auto x = lua_tonumber(l,2);
    auto y = lua_tonumber(l,3);
    auto ret = oc->multiply(x,y);
    lua_pushnumber(l,ret);
    return 1;
}

//注意这个函数在后面的用途,这个会被指定给元表的__index方法
static int LuaCallIndex(lua_State * l){
    auto * oc = *(OperateCpp **)lua_topointer(l, 1);
    auto filed = lua_tostring(l,2);
    if(strcmp(filed,"errorCode") == 0){
        lua_pushnumber(l, oc->errorCode);
    }else if(strcmp(filed, "multiply") == 0){
        lua_pushcfunction(l, LuaFuncMultiply);
    }
    return 1;
}

然后我们需要建立C++和Lua的联系,解释也直接在代码注释中给出:


void testLuaCallCpp(){
    std::cout << "start test Lua Call Cpp --------------------- " << std::endl;
    lua_State * l = luaL_newstate();
    luaL_openlibs(l);
    //和前面一样,我们用OperateCpp来命名OperateCpp对象的构造函数的转调函数,命名位OperateCpp,在Lua中调用就是OperateCpp()了
    //创建函数被调用时,每次实际就是创建了一个table,然后关联一个元表
    lua_pushcfunction(l,LuaCreateOperateCpp);
    lua_setglobal(l,"OperateCpp");
    //创建元表,提供给每次创建对象时候用,这个名字可以随意,只要在创建函数中取元表的时候要和这个对应
    //这里的元表可以看到和上面的构建方法是一样的,这个无所谓,一样不一样都行
    luaL_newmetatable(l, "OperateCpp");
    //指定元表的__gc方法,关联这个元表的table,在被释放时就会调用指定的方法
    lua_pushstring(l,"__gc");
    lua_pushcfunction(l,LuaDestroyOperateCpp);
    //这里相当于把堆栈的指针给移回到metatable上,以便于继续设置其他元方法
    lua_settable(l, -3);
    //设置元表__index的元方法,关联这个元表的table,每次获取内部属性或方法时就会调用指定的方法
    lua_pushstring(l, "__index");
    lua_pushcfunction(l,LuaCallIndex);
    lua_settable(l,-3);
	
    std::string content = loadString("../res/test2.lua");
    int ret = luaL_dostring(l,content.c_str());
    std::cout<<"doFile:" << ret << std::endl;
    lua_close(l);
}

至此,Lua和C/C++基本的相互调用就完成了,但是这样使用起来难免会感觉比较麻烦,我只是想做个简单的交互就要做这么多事情,无意是痛苦的,所以后面我们就要开始对这写复杂的调用做封装,让Lua和C++的交互变的更简单一些。

其他

笔记相关的代码在Github上,代码会不断变动,有需要的可以直接看对应的提交。此博客仅作为个人学习笔记及有兴趣的朋友参考使用,虚心接受建议与指正,不接受吐槽和批评,引用设计思想或代码希望注明出处,欢迎Fork和Star。wLuaBind代码地址


欢迎转载,转载请保留文章出处。湖广午王的博客[http://blog.csdn.net/junzia/article/details/95001209]


©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值