Lua脚本在C++下的舞步（三）

freeeyes

前两天一直忙于工作，没有时间来更新，呵呵，今天赶紧补上吧。
上一讲我把Lua基本的栈规则讲了一下，然后完善了一下我的CLuaFn类。让它可以支持任意参数数量和函数名称的传值。当然，这些功能是为了今天这篇文章而铺路的。
看了七猫的回帖，呵呵，确实应该说一下SWIG这个工具，说真的，我对这个工具理解不深，因为没有怎么用过，读过一些关于它的文章，似乎是帮你把C++的功能封装成一个Lua基本库的东西，但是后来研究，他可以很轻松帮你把公用函数封装成一个Lua的基本库(类似C++的dll)，但是对于我的需求而言，可能不太一样。因为我大量的是需要在C++里面进行数据传输以及变量的交互，所以为了紧贴C++，我需要很多关联数据的处理。
我是一名C++程序员，所以在很多时候，不想过多的使用Lua的特性，因为个人感觉，Lua的语法要比C++的更加灵活。而我更希望，在函数调用的某些习惯上，遵循一些C++的规则。
好了，废话少说，我们先来看一个类（头文件）。假设我们要把这个对象，传输给Lua进行调用。

1. #ifndef _TEST_H
2. #define _TEST_H
4. class CTest
5. {
6. public:
7.         CTest(void);
8.         ~CTest(void);
10.         char* GetData();
11.         void SetData(const char* pData);
13. private:
14.         char m_szData[200];
15. };
16. #endif

复制代码

这个类里面有两个函数，一个是GetData()，一个是SetData()，之所以这么写，我要让Lua不仅能使用我的类，还可以给这个类使用参数。
那么，cpp文件，我们姑且这样写。（当然，你可以进行修改，按照你喜欢的方式写一个方法，呵呵）

1. char* CTest::GetData()
2. {
3.         printf("[CTest::GetData]%s.\n", m_szData);
4.         return m_szData;
5. }
7. void CTest::SetData(const char* pData)
8. {
9.         sprintf(m_szData, "%s", pData);
10. }

复制代码

这是一个标准的类，我需要这个类在Lua里面可以创造出来，并赋予数值，甚至我可以把CTest作为一个Lua函数参数，传给Lua函数让它去给我处理。让我们来看看怎么做。如果使用标准的Lua语法，有点多，所以我就借用一下上次提到的tolua来做到这一切，我一句句的解释。姑且我们把这些代码放在LuaFn.cpp里面。

1. static int tolua_new_CTest(lua_State* pState)
2. {
3.         CTest* pTest = new CTest();
4.         tolua_pushusertype(pState, pTest, "CTest");
5.         return 1;
6. }
8. static int tolua_delete_CTest(lua_State* pState)
9. {
10.         CTest* pTest = (CTest* )tolua_tousertype(pState, 1, 0);
11.         if(NULL != pTest)
12.         {
13.                 delete pTest;
14.         }
15.         return 1;
16. }
18. static int tolua_SetData_CTest(lua_State* pState)
19. {
20.         CTest* pTest = (CTest* )tolua_tousertype(pState, 1, 0);
21.         const char* pData = tolua_tostring(pState, 2, 0);
23.         if(pData != NULL && pTest != NULL)
24.         {
25.                 pTest->SetData(pData);
26.         }
28.         return 1;
29. }
31. static int tolua_GetData_CTest(lua_State* pState)
32. {
33.         CTest* pTest = (CTest* )tolua_tousertype(pState, 1, 0);
35.         if(pTest != NULL)
36.         {
37.                 char* pData = pTest->GetData();
38.                 tolua_pushstring(pState, pData);
39.         }
41.         return 1;
42. }

复制代码

看看这几个静态函数在干什么。
我要在Lua里面使用CTest，必须让Lua里这个CTest对象能够顺利的创造和销毁。tolua_new_CTest()和tolua_delete_CTest()就是干这个的。
tolua_pushusertype(pState, pTest, "CTest"); 这句话的意思是，将一个已经在Lua注册的"CTest"对象指针，压入数据栈。
同理，CTest* pTest = (CTest* )tolua_tousertype(pState, 1, 0);是将数据栈下的对象以(CTest* )的指针形式弹出来。
tolua_SetData_CTest()函数和tolua_GetData_CTest分别对应CTest的SetData方法和GetData()方法。因为我们的SetData方法里面存在变量，那么同样，我们需要使用const char* pData = tolua_tostring(pState, 2, 0);将参数弹出来，然后输入到pTest->SetData(pData);对象中去，当然，你可以有更多若干个参数。随你的喜好。这里只做一个举例。
好了，你一定会问，这么多的静态函数，用在哪里？呵呵，当然是给Lua注册，当你把这些数据注册到Lua里面，你就可以轻松的在Lua中使用它们。
让我们看看，注册是怎么做到的。
还是在CLuaFn类里面，我们增加一个函数。比如叫做bool InitClass();

1. bool CLuaFn::InitClass()
2. {
3.         if(NULL == m_pState)
4.         {
5.                 printf("[CLuaFn::InitClass]m_pState is NULL.\n");
6.                 return false;
7.         }
9.         tolua_open(m_pState);
10.         tolua_module(m_pState, NULL, 0);
11.         tolua_beginmodule(m_pState, NULL);
13.         tolua_usertype(m_pState, "CTest");
14.         tolua_cclass(m_pState, "CTest", "CTest", "", tolua_delete_CTest);
16.         tolua_beginmodule(m_pState, "CTest");
17.         tolua_function(m_pState, "new", tolua_new_CTest);
18.         tolua_function(m_pState, "SetData", tolua_SetData_CTest);
19.         tolua_function(m_pState, "GetData", tolua_GetData_CTest);
20.         tolua_endmodule(m_pState);
22.         tolua_endmodule(m_pState);
24.         return true;
25. }

复制代码

上面的代码，就是我把上面的几个静态函数，绑定到Lua的基础对象中去。
tolua_beginmodule(m_pState, "CTest");是只注册一个模块，比如，我们管CTest叫做"CTest"，保持和C++的名称一样。这样在Lua的对象库中就会多了一个CTest的对象描述，等同于string,number等等基本类型，同理，你也可以用同样的方法，注册你的MFC类。是不是有点明白了？这里要注意，tolua_beginmodule()和tolua_endmodule()对象必须成对出现，如果出现不成对的，你注册的C++类型将会失败。
tolua_function(m_pState, "SetData", tolua_SetData_CTest);指的是将Lua里面CTest对象的"SetData"绑定到你的tolua_SetData_CTest()函数中去。

好的，让我们来点激动人心的东西。还记得我们的Simple.lua的文件么。我们来改一下它。

1. function func_Add(x, y)
2.   local test = CTest:new();
3.   test:SetData("I'm freeeyes!");
4.   test:GetData();
5.   
6.   return x..y;
7. end

复制代码

我在这个函数里面，New了一个CTest对象，并进行赋值操作，最后把结果打印在屏幕上。你或许会问，最后一句不是x+y么，怎么变成了x..y，呵呵，在Lua中，..表示联合的意思，就好比在C++里面， string strName += "freeeyes"。原来觉得x+y有点土，索性返回一个两个字符串的联合吧。
好了，我们已经把我们的这个CTest类注册到了Lua里面，让我们来调用一下吧。修改一下Main函数。变成以下的样子。

1. int _tmain(int argc, _TCHAR* argv[])
2. {
3.         CLuaFn LuaFn;
5.         LuaFn.InitClass();
7.         LuaFn.LoadLuaFile("Sample.lua");
9.         CParamGroup ParamIn;
10.         CParamGroup ParamOut;
12.         char szData1[20] = {'\0'};
13.         sprintf(szData1, "[freeeyes]");
14.         _ParamData* pParam1 = new _ParamData(szData1, "string", (int)strlen(szData1));
15.         ParamIn.Push(pParam1);
17.         char szData2[20] = {'\0'};
18.         sprintf(szData2, "[shiqiang]");
19.         _ParamData* pParam2 = new _ParamData(szData2, "string", (int)strlen(szData2));
20.         ParamIn.Push(pParam2);
21.         
22.         char szData3[40] = {'\0'};
23.         _ParamData* pParam3 = new _ParamData(szData3, "string", 40);
24.         ParamOut.Push(pParam3);
26.         LuaFn.CallFileFn("func_Add", ParamIn, ParamOut);
28.         char* pData = (char* )ParamOut.GetParam(0)->GetParam();
29.         printf("[Main]Sum = %s.\n", pData);
32.         getchar();
34.         return 0;
35. }

复制代码

如果你完全按照我的，你就可以编译你的工程了，运行一下，看看是啥结果？

[CTest::GetData]I'm freeeyes!.
[Main]Sum = [freeeyes][shiqiang].
看看，是不是和我输出的一样？

呵呵，有意思吧，你已经可以在Lua里面用C++的函数了，那么咱们再增加一点难度，比如，我有一个CTest对象，要作为一个参数，传输给func_Add()执行，怎么办？
很简单，如果你对上面的代码仔细阅读，你会发现下面的代码一样简洁。为了支持刚才要说的需求，我们需要把Sample.lua再做一点修改。

1. function func_Add(x, y, f)
2.   f:SetData("I'm freeeyes!");
3.   f:GetData();
4.   return x..y;
5. end

复制代码

f假设就是我们要传入的CTest对象。我们要在Lua里面使用它。（我们的CLuaFn都不用改，把main函数稍微改一下即可，来看看怎么写。）

// LuaSample.cpp : 定义控制台应用程序的入口点。
//

1. #include "stdafx.h"
2. #include "LuaFn.h"
4. int _tmain(int argc, _TCHAR* argv[])
5. {
6.         CLuaFn LuaFn;
8.         LuaFn.InitClass();
10.         LuaFn.LoadLuaFile("Sample.lua");
12.         CParamGroup ParamIn;
13.         CParamGroup ParamOut;
15.         char szData1[20] = {'\0'};
16.         sprintf(szData1, "[freeeyes]");
17.         _ParamData* pParam1 = new _ParamData(szData1, "string", (int)strlen(szData1));
18.         ParamIn.Push(pParam1);
20.         char szData2[20] = {'\0'};
21.         sprintf(szData2, "[shiqiang]");
22.         _ParamData* pParam2 = new _ParamData(szData2, "string", (int)strlen(szData2));
23.         ParamIn.Push(pParam2);
25.         //只追加了这里
26.         CTest* pTest = new CTest();
27.         _ParamData* pParam3 = new _ParamData(pTest, "CTest", sizeof(CTest));
28.         ParamIn.Push(pParam3);
29.        //追加结束
30.         
31.         char szData4[40] = {'\0'};
32.         _ParamData* pParam4 = new _ParamData(szData4, "string", 40);
33.         ParamOut.Push(pParam4);
35.         LuaFn.CallFileFn("func_Add", ParamIn, ParamOut);
37.         char* pData = (char* )ParamOut.GetParam(0)->GetParam();
38.         printf("[Main]Sum = %s.\n", pData);
41.         getchar();
43.         return 0;
44. }

复制代码

好了，就这么点代码，改好了，我们再Build一下，然后点击运行。看看输出结果，是不是和以前的一样？
恩，是不是有点兴奋了？你成功的让Lua开始调用你的C++对象了！并且按照你要的方式执行！还记得我曾在第一篇文章里面许诺过，我会让你画出一个MFC窗体么？呵呵，如果你到现在依然觉得很清晰的话，说明你的距离已经不远了。

既然已经到了这里，我们索性再加点难度，如果我要把CTest作为一个对象返回回来怎么做？很简单，且看。

1. int _tmain(int argc, _TCHAR* argv[])
2. {
3.         CLuaFn LuaFn;
5.         LuaFn.InitClass();
7.         LuaFn.LoadLuaFile("Sample.lua");
9.         CParamGroup ParamIn;
10.         CParamGroup ParamOut;
12.         char szData1[20] = {'\0'};
13.         sprintf(szData1, "[freeeyes]");
14.         _ParamData* pParam1 = new _ParamData(szData1, "string", (int)strlen(szData1));
15.         ParamIn.Push(pParam1);
17.         char szData2[20] = {'\0'};
18.         sprintf(szData2, "[shiqiang]");
19.         _ParamData* pParam2 = new _ParamData(szData2, "string", (int)strlen(szData2));
20.         ParamIn.Push(pParam2);
22.         CTest* pTest = new CTest();
23.         _ParamData* pParam3 = new _ParamData(pTest, "CTest", sizeof(CTest));
24.         ParamIn.Push(pParam3);
25.         
26.         CTest* pTestRsult = NULL;
27.         _ParamData* pParam4 = new _ParamData(pTestRsult, "CTest", sizeof(pTestRsult));
28.         ParamOut.Push(pParam4);
30.         LuaFn.CallFileFn("func_Add", ParamIn, ParamOut);
32.         //接受Lua返回参数为CTest类型，并调用其中的方法。
33.         pTestRsult = (CTest* )ParamOut.GetParam(0)->GetParam();
34.         pTestRsult->GetData();
36.         getchar();
38.         return 0;
39. }

复制代码

好，编译，执行。呵呵，看到了吧。

看到这里，如果你能看的明白，说明你已经对Lua如何调用C++接口，以及C++如何调用Lua有了一定的理解。当然，我写的这个类也不是很完善，不过做一半的Lua开发，应该是够用了。以以上的方式，你可以使用Lua驾驭你的C++代码。
好了，咱们既然已经说到这里了，再深一步，如果我的类是继承的，怎么办？呵呵，很好的问题。
比如，我的CTest继承了一个CBase，我的CBase又继承了一个。。。
在Lua里面，一样简单，我拿MFC的例子来举例吧，想必大家更喜欢看。
比如 CCmdTarget继承自CObject。
那么我在注册的时候可以这么写。

tolua_cclass(tolua_S, "CCmdTarget",      "CCmdTarget",      "CObject",            NULL);
这个表示CCmdTarget继承自CObject对象。
当然，MFC里面还会有很多类型，比如常数，Lua一样能处理。
举个例子说。

tolua_constant(tolua_S, "ES_AUTOHSCROLL",   ES_AUTOHSCROLL);
这样注册，你就可以在 Lua里面使用ES_AUTOHSCROLL这个常数，它会自动绑定ES_AUTOHSCROLL这个C++常数对象。

呵呵，说了这么多，让我们来点实际的。我给大家一个我以前写的MFC封装类（由于代码太多，我变成附件给大家），你们可以调用，当然，如果你有兴趣，就用我的MFC类，来做一个你喜欢的窗体吧，当然，你必须要用Lua脚本把它画出来，作为最后的考验，呵呵。

（以上代码都在XP SP3 VS2005下编译通过）
最终工程附件如下：

Jack

支持！！！很受教啊！~~~

true

[Copy to clipboard] [ - ]CODE:
function func_Add(x, y, f)
  f:SetData("I'm freeeyes!");
  f:GetData();
  return x..y;
end

----------------如果f中SetData是模板形式，能这样调用吗f:SetData<string>("I'm freeeyes!");

sugar

支持楼主的分享态度.

zb211208

非常好，谢谢！

makelife

{:2_30:}谢谢楼主的无私分享啊

泡菜丝丝

脚本和C++整合要是能自动类型识别就帅了，类型和接口太多的时候注册和修改会让人崩溃

freeeyes

lua是没有类型的概念的，对于类似lua和python来说，任何数据对象都是一个二进制内存块，只有进行语法解析的时候才会做相应的转换。这样做有助于开发者迅速上手，不用学习繁复的各种数据类型。对于C++而言，与其对应是稍微繁琐一些，不过写一个通用的类，其实并不是很复杂。