让Lua和C++牵手

1. Lua的堆栈和全局表

我们来简单解释一下Lua的堆栈和全局表,堆栈大家应该会比较熟悉,它主要是用来让C++和Lua通信的,是的,它们并不认识对方,只能通过堆栈来沟通,就像写信一样。

 

Lua的全局表又是什么呢?可以想象成是一个map哈希表结构,比如Lua有一个变量:

name = “hello”

那么,全局表就存放了”name””hello”的对应关系,Lua可以通过name在全局表中查找到hello。应该是这样的~

 

2. Lua和C++的第一次通信

现在来设计一个场景,C++在一次JavaScript开发者大会上看到Lua在演讲,于是C++被Lua深深吸引了。

 

我们来看看这位美丽的Lua小姐长什么样:

[plain] view plaincopyprint?

1. -- hello.lua 文件  

2. myName = "beauty girl"  


 

OK,一位简单又美丽Lua小姐。

然后,C++想知道Lua叫什么名字,所以,它们必须要通信了。来看看通信流程:

 

请注意红色数字,代表通信顺序:

1 C++想获取Lua的myName字符串的值,所以它把myName放到Lua堆栈(栈顶),以便Lua能看到

2 Lua从堆栈(栈顶)中获取myName,此时栈顶再次变为空

3 Lua拿着这个myName去Lua全局表查找myName对应的字符串

4 全局表返回一个字符串”beauty girl”

5 Lua把取得的“beauty girl”字符串放到堆栈(栈顶)

6 C++可以从Lua堆栈中取得“beauty girl”,也就是这位美丽的Lua小姐的名字了~

世界如此美妙,这是如此的简单。

 

 

 

 

1. 引入头文件

我们来看看要在C++中使用Lua,需要些什么东西

[cpp] view plaincopyprint?

1. /*  

2.    文件名:    HelloLua.h  

3.    描 述:    Lua Demo 

4.    创建人:    笨木头 (CSDN博客:http://blog.csdn.net/musicvs)  

5.  

6.    创建日期:   2012.12.24  

7. */    

8.   

9. #ifndef __HELLO_LUA_H_  

10. #define __HELLO_LUA_H_  

11.   

12. #include "cocos2d.h"  

13.   

14. extern "C" {  

15. #include <lua.h>  

16. #include <lualib.h>  

17. #include <lauxlib.h>  

18. };  

19.   

20. using namespace cocos2d;  

21.   

22. class HelloLua : public CCLayer {  

23. public:  

24.     CREATE_FUNC(HelloLua);  

25.     virtual bool init();  

26.   

27.     static CCScene* scene();  

28. };  

29.   

30. #endif  


看到红色粗体的代码了吗?

在这:

extern "C" {

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

};

 

记住了,Lua是C语言库,所以在C++中使用必须用extern “C”声明,让编译器知道。

有了这些,我们就能开始使用Lua了。

 

啊,对了,还少一样东西,不过这个不需要我们做了,那就是引入Lua的库,没有库,我们怎么包含头文件都没用。

不过没关系,Cocos2d-x本来就支持Lua,所以这一步我们省下了,为了保险起见,我在新建Demo项目的时候勾选了支持Lua。

建议大家首先能创建一个支持Lua的Cocos2d-x项目,并且能编译运行,然后再继续往下看~

 

我教?我不懂~

 

2. 开始使用

来看看我们的cpp文件,我们要开始使用Lua了~!

[cpp] view plaincopyprint?

1. #include "HelloLua.h"  

2.   

3. CCScene* HelloLua::scene() {  

4.     CCScene* scene = CCScene::create();  

5.     CCLayer* layer = HelloLua::create();  

6.     scene->addChild(layer);  

7.   

8.     return scene;  

9. }  

10.   

11. bool HelloLua::init() {  

12.     lua_State* pL = lua_open();  

13.     luaopen_base(pL);  

14.     luaopen_math(pL);  

15.     luaopen_string(pL);  

16.   

17.     /* 1.执行Lua脚本,返回0代表成功 */  

18.     /* 2.重置栈顶索引 */  

19.     /* 3.判断栈顶的值的类型是否为String, 返回非0值代表成功 */  

20.   /* 4.获取栈顶的值 */  

21.     

22.     lua_close(pL);  

23.     return true;  

24. }  


 

为了不一下子就一大堆代码吓坏大家,我把部分代码先删了,我们来看看现在这个代码的情况:

1 HelloLua是一个场景

2 HelloLua有一个init函数

3 我就喜欢旁白吐槽~

4 要使用Lua,首先要有一个lua_State,这是什么呢?我引用《游戏人工智能编程案例精粹》一书的一句话(191页):每一个运行的脚本文件都在一个动态分配的叫做lua_State的数据结构中运行”。不明白的话,也没有关系,我们就把lua_State当成是一个Lua的身体,Lua在做任何事情的时候都不能没有身体。

5 接下来看到几句话:luaopen_base(pL);luaopen_math(pL);luaopen_string(pL);

Lua有一些标准库,要使用这些库,就要用luaopen_**去加载这些库

6 然后最后还有一句话:lua_close(pL),一看就知道了,用来释放内存的。

7 旁白呢?

 

3. 执行Lua脚本

现在我们来一步步完善我们的代码,执行Lua脚本很简单,看看:

[cpp] view plaincopyprint?

1. bool HelloLua::init() {  

2.     lua_State* pL = lua_open();  

3.     luaopen_base(pL);  

4.     luaopen_math(pL);  

5.     luaopen_string(pL);  

6.   

7.     /* 1.执行Lua脚本,返回0代表成功 */  

8.     int err = luaL_dofile(pL, "helloLua.lua");  

9.     CCLOG("open : %d", err);  

10.   

11.     /* 2.重置栈顶索引 */  

12.     lua_settop(pL, 0);  

13.     lua_getglobal(pL, "myName");  

14.   

15.     /* 3.判断栈顶的值的类型是否为String, 返回非0值代表成功 */  

16.   /* 4.获取栈顶的值 */  

17.     

18.     lua_close(pL);  

19.     return true;  

20. }  


 

我们还要新建一个lua文件,很简单,新建一个文本文件,把后缀名改为lua就行了。现在我们来创建一个helloLua.lua文件:

[plain] view plaincopyprint?

1. -- helloLua.lua文件  

2. myName = "beauty girl"  


 

好,lua文件也有了,在C++中只要调用luaL_dofile就能执行lua脚本了,注意了,必须把lua_State也作为参数传给luaL_dofile,前面已经说了,身体不能少。

 

 

4. 重置栈顶索引, 将全局变量放到堆栈中

 

lua_settop(pL, 0);是为了确认让栈顶的索引置为0,因为我们操作栈的时候是根据索引来操作的。置0之后,我们入栈的第一个元素的索引就是1。

那,lua_getglobal(pL, “myName”);又是什么呢?咋一看好像是从lua中取得myName这个全局变量的值,但并不是这样的,虽然最终也是这样。

 

我们之前说过了,Lua和C++是不能直接通信的,要通过堆栈来通信。

因此,lua_getglobal(pL, “myName”);只是把myName放到了栈中,然后lua就会通过myName去全局表寻找,找到myName对应的字符串“beauty girl”,再放到栈中。(第01章的时候介绍过的步骤,还记得吗?不记得的建议大家去看看~)

1.C++myName放到堆栈

2.lua从堆栈取得myName

3.luamyNamelua全局表查找获取myName对应的字符串,得到“beauty girl”字符串,然后再放回堆栈

4.最后C++就可以从堆栈中取得“beauty girl”字符串? 

 

5. 最后一步,C++取得字符串

我们来看看完整的代码:

[cpp] view plaincopyprint?

1. bool HelloLua::init() {  

2.     lua_State* pL = lua_open();  

3.     luaopen_base(pL);  

4.     luaopen_math(pL);  

5.     luaopen_string(pL);  

6.   

7.     /* 1.执行Lua脚本,返回0代表成功 */  

8.     int err = luaL_dofile(pL, "helloLua.lua");  

9.     CCLOG("open : %d", err);  

10.   

11.     /* 2.重置栈顶索引 */  

12.     lua_settop(pL, 0);  

13.     lua_getglobal(pL, "myName");  

14.   

15.     /* 3.判断栈顶的值的类型是否为String, 返回非0值代表成功 */  

16.     int isstr = lua_isstring(pL, 1);  

17.     CCLOG("isstr = %d", isstr);  

18.   

19.     /* 4.获取栈顶的值 */  

20.     const char* str = lua_tostring(pL, 1);  

21.     CCLOG("getStr = %s", str);  

22.   

23.     lua_close(pL);  

24.     return true;  

25. }  


 

lua_getglobal已经完成了很多工作了,现在堆栈上就放着“beauty girl”字符串,我们只要去取就可以了。

获取堆栈的值有很多种方法,分别对应不同的变量类型:

lua_toboolean

lua_toNumber

lua_tocfunction

lua_tostring

我就不全部举例了,现在我们要用lua_tostring来获取栈顶的值。

最后,在AppDelegate.cpp中把默认启动场景设为我们的HelloLua场景,用调试模式运行项目,将看到以下日志:

open : 0

isstr = 1

getStr = beauty girl

好,本章到此结...

 

对了对了,Lua还提供了很多函数供我们判断堆栈中的变量类型,比如lua_isstring、lua_isnumber等等,和lua_tostring等函数是对应的。返回非0值表示类型正确。

一般在取值之前都要判断一下,不能程序很可能意外崩溃~!

 

好~本章到此结束~

6. 赠送的

最后再告诉大家一个笑眯眯~

那就是用lua_pop(pL, 1); 可以清除指定堆栈上的数据~

 

 

 

 

 

在这里我仅简单解释一下Lua堆栈的索引,因为我们在很多操作里都涉及到堆栈的索引,比如上一章中我们要从堆栈中取得一个字符串,就必须给出堆栈索引:

[cpp] view plaincopyprint?

1. /* 获取栈顶的值 */  

2.     const char* str = lua_tostring(pL, 1);  


如果对堆栈索引不清晰的话,将会很纠结。

《游戏人工智能编程案例精粹》一书的200页,有一张图,很好地表达了Lua的堆栈索引是如何定义的,我照着画了一张:

 

我们很明显的看到堆栈的索引方式有两种,一种是正数索引,一种是负数索引。

并且咋一看,好像两种索引方式的规则是相反的,其实不然,我们来认真数数:

1. 正数索引,栈底是1,然后一直到栈顶是逐渐+1,最后变成9(9大于1)

2. 负数索引,栈底是-9,然后一直到栈顶是逐渐+1,最后变成-1(-1大于-9)

 

 

大家不觉得奇怪吗?为什么要用两种方式?好混乱~!

我也觉得,但是有一点好处,看看它们各自的好处:

1. 正数索引,不需要知道栈的大小,我们就能知道栈底在哪,栈底的索引永远是1

2. 负数索引,不需要知道栈的大小,我们就能知道栈顶在哪,栈顶的索引永远是-1

 

 

 

 

 


1. 什么是table

table是Lua里最强大的数据类型,我们可以当成是数组,但是它又和数组有点不一样,建议大家看看Lua的语法教程,因为我对table也没有熟悉到可以给大家解释的程度。

 

2. 获取table变量

现在,我们给helloLua.lua文件添加一个table全局变量:

[cpp] view plaincopyprint?

1. -- helloLua.lua文件  

2. myName = "beauty girl"  

3.   

4. helloTable = {name = "mutou", IQ = 125}  


 

我们看到,多了一个helloTable的变量,它和数组十分相似,又和HashMap有点类似,总之它很强大。

话说,125乘以2等于多少?...250 ....O O!

获取helloTable变量的方式和以前是一样的:

[cpp] view plaincopyprint?

1. /* 取得table变量,在栈顶 */  

2.     lua_getglobal(pL, "helloTable");  


 

这样,helloTable变量就被存放到栈顶。

可我们并不是要取table变量,因为C++中是无法识别Lua的table类型的,所以我们要取得table中具体的值,也就是name和IQ的值。

 

3. lua_gettable函数

有一个和lua_getglobal类似的函数,叫做lua_gettable,顾名思义,它是用来取得table相关的数据的。

 

lua_gettable函数会从栈顶取得一个值,然后根据这个值去table中寻找对应的值,最后把找到的值放到栈顶。

lua_pushstring()函数可以把C++中的字符串存放到Lua的栈里;

然后再用lua_gettable()取执行前面所说的步骤,lua_gettable的第二个参数是指定的table变量在栈中的索引。

 

为了照顾旁白这个笨蛋,我们画个图来理解:

这是初始状态,堆栈里还没有任何东西,那么,现在要先把helloTable变量放到栈顶:

[cpp] view plaincopyprint?

1. /* 取得table变量,在栈顶 */  

2.     lua_getglobal(pL, "helloTable");  


 

然后就变成了这样:

接着,我们要取得table的name对应的值,那么,先要做的就是把”name”字符串入栈:

[cpp] view plaincopyprint?

1. /* C++的字符串放到Lua的栈中,此时,栈顶变为“name” helloTable对象变为栈底 */  

2.     lua_pushstring(pL, "name");  


 

然后变成这样:

 

注意了,我把栈的索引也加上了,因为我们即将要使用,这次我们用负数索引(不了解负数的索引的朋友请阅读第03章的教程哈~)。

由于”name”的入栈,现在helloTable变量已经不在栈顶了。

接着,我们调用要做最重要的一步了,取得name在table中对应的值:

[cpp] view plaincopyprint?

1. /*  

2.         table对象寻找“name”对应的值(table对象现在在索引为-2的栈中,也就是当前的栈底), 

3.         取得对应值之后,将值放回栈顶 

4.     */  

5.     lua_gettable(pL, -2);  


 

此时,栈变成这样:

 

lua_gettable倒底做了什么事情?

首先,我们来解释一下lua_gettable的第二个参数,-2是什么意思,-2就是刚刚helloTable变量在栈中的索引。

然后,Lua会去取得栈顶的值(之前的栈顶是”name”),然后拿着这个值去helloTable变量中寻找对应的值,当然就找到”mutou”了。

最后,Lua会把找到的值入栈,于是”mutou”就到了栈顶了。

 

最后我们只需要取出栈顶的数据就可以了,完整代码如下:

[cpp] view plaincopyprint?

1. /* 初始化 */  

2.     lua_State* pL = lua_open();  

3.     luaopen_base(pL);  

4.   

5.     /* 执行脚本 */  

6.     luaL_dofile(pL, "helloLua.lua");  

7.   

8.     /* 取得table变量,在栈顶 */  

9.     lua_getglobal(pL, "helloTable");  

10.   

11.     /* C++的字符串放到Lua的栈中,此时,栈顶变为“name” helloTable对象变为栈底 */  

12.     lua_pushstring(pL, "name");  

13.   

14.     /*  

15.         table对象寻找“name”对应的值(table对象现在在索引为-2的栈中,也就是当前的栈底), 

16.         取得对应值之后,将值放回栈顶 

17.     */  

18.     lua_gettable(pL, -2);  

19.   

20.     /* 现在表的name对应的值已经在栈顶了,直接取出即可 */  

21.     const char* sName = lua_tostring(pL, -1);  

22.     CCLOG("name = %s", sName);  

 

 

 

 

 

 


经过前面几章的介绍,相信大家对Lua的堆栈已经比较熟悉了,如果还不是很熟悉的朋友,建议多看几遍前面的教程,或者多敲几次代码。

那么,如果已经对Lua的堆栈比较熟悉,接下来的内容就很简单了。

今天我们来看看C++如何调用Lua的函数,先看看现在Lua文件是什么样的:

[plain] view plaincopyprint?

1. -- helloLua.lua文件  

2. myName = "beauty girl"  

3.   

4. helloTable = {name = "mutou", IQ = 125}  

5.   

6. function helloAdd(num1, num2)  

7.     return (num1 + num2)  

8. end;  


 

我们看到多了个helloAdd函数,那么,现在我们要用C++调用这个函数。

 

直接上代码了:

[cpp] view plaincopyprint?

1. /* C++调用lua的函数 */  

2. void HelloLua::demo3() {  

3.     lua_State* pL = lua_open();  

4.     luaopen_base(pL);  

5.   

6.     /* 执行脚本 */  

7.     luaL_dofile(pL, "helloLua.lua");  

8.   

9.     /* helloAdd函数对象放到栈中 */  

10.     lua_getglobal(pL, "helloAdd");  

11.   

12.     /* 把函数所需要的参数入栈 */  

13.     lua_pushnumber(pL, 10);  

14.     lua_pushnumber(pL, 5);  

15.   

16.     /*  

17.         执行函数,第一个参数表示函数的参数个数,第二个参数表示函数返回值个数  

18.         Lua会先去堆栈取出参数,然后再取出函数对象,开始执行函数 

19.     */  

20.     lua_call(pL, 2, 1);  

21.   

22.     int iResult = lua_tonumber(pL, -1);  

23.     CCLOG("iResult = %d", iResult);  

24. }  


 

简单说明一下步骤:

1 执行脚本

2 helloAdd函数放到栈中:lua_getglobal(pL, “helloAdd”) 。(旁白:看吧,我就知道~!)

3 helloAdd有2个参数,我们要把参数传递给lua,所以2个参数都要放到栈里。

4 2和第3步已经把函数所需要的数据都放到栈里了,接下来只要告诉lua去栈里取数据,执行函数~! 调用lua_call即可,注释已经很详细了,这里就不重复了。

 

 

 

 

 

 

 

1. Lua调用C++的函数

Lua要调用C++的函数还是蛮方便的,首先,我们来创建一个c++函数先:

[cpp] view plaincopyprint?

1. public:  

2.   static int getNumber(int num);  

3.     

4.     

5. int HelloLua::getNumber( int num ) {  

6.     CCLOG("getNumber num = %d", num);  

7.     return num + 1;  

8. }  


类的什么的,我就忽略了,直接上函数。

 

这是一个很简单的函数,给出一个值,返回一个+1后的值。

现在,我们想在Lua中调用这个函数,得多写一个函数。

 

[cpp] view plaincopyprint?

1. public:  

2. static int cpp_GetNumber(lua_State* pL);  

3.   

4.   

5. int HelloLua::cpp_GetNumber( lua_State* pL ) {  

6.     /* 从栈顶中取一个值 */  

7.     int num = (int)lua_tonumber(pL, 1);  

8.   

9.     /* 调用getNumber函数,将返回值入栈 */  

10.     lua_pushnumber(pL, getNumber(num));  

11.   

12.     /* 返回值个数,getNumber只有一个返回值,所以返回1 */  

13.     return 1;  

14. }  


 

这是怎么回事呢?我们很清楚,Lua和C++只能通过堆栈通信,所以Lua是不可能直接调用getNumber函数的,所以我们建立一个cpp_GetNumber函数作为中介。

cpp_GetNumber函数有一个lua_State* pL参数,有了这个参数,c++就能从Lua的堆栈中取值了,剩下的都很简单,不想过多的解释...

 

 

1) 首先,Lua脚本里会调用cpp_GetNumber函数,至于为什么能调用,一回解释,我知道旁白一定会问的。

2)2 cpp_GetNumber被调用时,一切又回到C++对Lua的操作了,栈顶里会存放函数所需要的参数,取出来用就可以的。

3 Lua调用cpp_GetNumber之后,需要一个结果,当然,这个结果同样只能存放在栈里,所以理所当然地要把getNumber的结果入栈。

4 最后,cpp_GetNumber return了一个值,这个值不是函数的执行结果,而是getNumber需要返回值的个数(Lua支持多个返回值的函数)

旁白,你明白了么?

 

好,既然大家都明白了,我就不多说了~

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值