带来一篇Lua剧本在C++下的舞步(进门指引)

如果您觉得本篇CentOSLinux教程讲得好，请记得点击右边漂浮的分享程序，把好文章分享给你的小伙伴们！如今，愈来愈多的C++办事器和客户端融进了剧本的撑持，特别在网游范畴，剧本言语已浸透到了各个方面，好比你能够在你的客户端增添一个剧本，这个剧本将会帮你在界面上显现新的数据，亦或帮你完成某些义务，亦或帮你检察其余玩家大概NPC的形态。。。云云等等。
可是我以为，实在剧本言语与C++的分离，远远比你在游戏中看到的殊效要来的迅猛。它能够使用到各个方面的范畴，好比你最多见的使用范畴。好比，你能够用文本编纂器，写一个剧本言语，然后用你的步伐加载一下，就会发生出很壮丽的界面。亦或一两句文本言语，就会让你的步伐发送数据给办事器，是否是很酷呢？
原本我想，写一篇关于支流剧本言语Lua和Python的文章，可是感到如许过于有趣，因而分隔来逐一先容，信任对C++懂得的你，看过我的文章后会对剧本言语这类器材发生浓郁的乐趣，我想起之前听的一个故事，昔时Java的制造者授课的时分，一入手下手先拿一个复杂的不克不及复杂的小例子，不休的扩大，最初成为一个庞大而完善的步伐。明天我也就如许实行一下吧，呵呵。
固然，我自己不敢说对剧本言语洞若观火，只能说稍微把握一些，用过几年，公允的地方请人人斧正。
上面，入手下手吧，先说LUA！（本文面向初学者）
Lua言语（http://www.lua.org/），想必很多步伐员都听过，据我所知，因为《魔兽天下》内里对它的加载，它一会儿酿成了良多游戏开辟者竞相研讨的工具，至于这个巴西制造者么，我不外多先容，人人有乐趣能够谷歌一下。实在网上有良多关于lua的课本和例子，说真的，关于昔时的我而言，几近看不懂，事先很忧郁，感到Lua庞大的要命，有些害怕，厥后沉下心来一点点研讨，以为实在仍是蛮简便的。只是网上的材料也许倾向于某些功效，招致了逻辑和代码的庞大。厥后总结，实在进修一种剧本言语，完整能够抱着抓紧的心态一点点的研讨，反而效果会更好。
在讲代码之前，我要说Lua的一些特性，这些特性有益于你在庞大的代码挪用中，明晰的把握两头的前因后果。实践上，你能经常用到的lua的API，不外凌驾10个，再庞大的逻辑。基础上也是这么多API构成的。至于它们是甚么，上面的文章会先容。别的一个主要之主要的观点，就是栈。Lua与其余言语交互和互换数据，是经由过程栈完成的。实在复杂的注释一下，你能够把栈设想成一个箱子，你要给他数据，就要按按次一个个的把数据放出来，固然，Lua实行终了，大概会有了局前往给你，那末Lua还会使用你的箱子，一个个的持续放下往。而你掏出前往数据呢，要从箱子顶上掏出，假如你想要取得你的输出参数呢？那也很复杂，依照顶上前往数据的个数，再按按次一个个的掏出，就好了。不外这里提示人人，关于栈的地位，永久是绝对的，好比-1代表的是以后栈顶，-2代表的是以后栈顶下一个数据的地位。栈是数据互换的中央，必定要有一些栈的观点。
好了，基本的lua语法不在这里讲，百度一下有良多。
先往http://www.lua.org/往下载一个最新的Lua代码（如今不乱版是lua-5.1.4）。它的代码是用C写的，以是很简单兼容良多平台。
在linux下，目次src下就有专门的Makefile。很复杂，啥都不必做，指定一下地位编译便可。
在windows下，以VS2005为例，创建一个空的静态库工程（最好不利用预编译头，把预编译头的选项勾往失落），然后把src下的一切文件（除Makefile）一股脑拷到工程中往。然后将这些文件增加到你的工程中，编译，会天生一个*.llib(*是你起的lua库名)，行了，创建一个目次lib，把它拷已往，然后再创建一个include的文件夹，把你工程目次下的lua.h，lualib.h，lauxlib.h，拷贝已往。行了，拿着这两个文件夹，你就能够在你的工程里利用lua了。
行了，质料齐了，我们来看看怎样写一个复杂的lua步伐吧。
创建一个文件，起名Sample.lua
内里增加如许的代码。
functionfunc_Add(x,y)
returnx+y;
end
这是一个尺度的lua语法，一个函数，完成复杂的a+b操纵，并前往操纵了局。
保留加入。
多一句嘴，在Lua内里，是能够撑持多半据前往的。
好比你这么写：
functionfunc_Add(x,y)
returnx+y,x-y;
end
意义是前往第一个参数是相加的了局，第二个是相减的了局，也是能够的。在lua内里没有范例的观点。固然，在C++承受如许的前往值的时分，也很复杂，请往下看。
好了，质料完备了，我们来看看C++步伐怎样挪用它。
起首，创建一个类，卖力加载这个lua文件，并实行函数操纵，我们临时叫做CLuaFn
要加载这个lua文件，依照一般的思绪，我们应当先加载，然后再挪用分歧的函数。恩，对了，我们就这么做。
extern“C”
{
#include“lua.h”
#include“lualib.h”
#include“lauxlib.h”
};
classCLuaFn
{
public:
CLuaFn(void);
~CLuaFn(void);
voidInit();//初始化Lua工具指针参数
voidClose();//封闭Lua工具指针
boolLoadLuaFile(constchar*pFileName);//加载指定的Lua文件
boolCallFileFn(constchar*pFunctionName,intnParam1,intnParam2);//实行指定Lua文件中的函数
private:
lua_State*m_pState;//这个是Lua的State工具指针，你能够一个lua文件对应一个。
};
恩，头文件就这么多，看看，一点也不庞大吧，看了cpp我想你会更乐意，由于代码一样很少。我一个个函数给你们先容。
voidCLuaFn::Init()
{
if(NULL==m_pState)
{
m_pState=lua_open();
luaL_openlibs(m_pState);
}
}
初始化函数，尺度代码，没啥好说的，lua_open()是前往给你一个lua工具指针，luaL_openlibs()是一个好器材，在lua4，初始化要做一年夜堆的代码，好比加载lua的string库，io库，math库等等等等，代码味同嚼蜡一年夜堆，实在都是不用要的，由于这些库你基础都必要用到，除实习你的打字才能其余意义不年夜，由于代码写法都是流动的。因而在5今后，Lua的制造者修正了良多，这就是其一，一句话帮你加载了一切你大概用到的Lua基础库。
voidCLuaFn::Close()
{
if(NULL!=m_pState)
{
lua_close(m_pState);
m_pState=NULL;
}
}
望文生义，我用完了，封闭我的Lua工具并开释资本。呵呵，尺度写法，没啥好说的。
boolCLuaFn::LoadLuaFile(constchar*pFileName)
{
intnRet=0;
if(NULL==m_pState)
{
printf(“[CLuaFn::LoadLuaFile]m_pStateisNULL./n”);
returnfalse;
}
nRet=luaL_dofile(m_pState,pFileName);
if(nRet!=0)
{
printf(“[CLuaFn::LoadLuaFile]luaL_loadfile(%s)isfile(%d)(%s)./n”,pFileName,nRet,lua_tostring(m_pState,-1));
returnfalse;
}
returntrue;
}
呵呵，这个有点意义，加载一个Lua文件。
这里我要具体的说一下，由于Lua是剧本言语，加载lua文件自己的时分才会编译。
以是，保举人人在加载文件的时分只管放在步伐的初始化中，由于当你实行luaL_dofile()函数的时分，Lua会启用语法剖析器，往剖析你的剧本语法是不是切合Lua划定规矩，假如你胡乱的传一个文件已往，Lua就会告知你文件语法毛病，没法加载。假如你的Lua剧本很年夜，函数良多，语法剖析器会对照耗时，以是，加载的时分，只管放在符合的中央，并且，关于一个Lua文件而言，重复加载luaL_dofile()除会使你的CPU变热没有任何意义。
也许你对printf(“[CLuaFn::LoadLuaFile]luaL_loadfile(%s)isfile(%d)(%s)./n”,pFileName,nRet,lua_tostring(m_pState,-1));这句话很感乐趣，这个在干甚么？这里我先说lua_tostring(m_pState,-1)这是在干甚么，还记得我说的Lua是基于栈传输数据的么？那末，假如报错，我怎样晓得毛病是甚么？luaL_dofile尺度前往一个int，我总不克不及到lua.h内里遍历这个nRet是啥意义吧，恩，Lua制造者早就为你想好了，只不外你必要略微动一下你的头脑。Lua的制造者在语法剖析器剖析你的语法的时分，发明毛病，会有一段笔墨告知你是甚么毛病，它会把这个字符串放在栈顶。那末，怎样获得栈顶的字符串呢？lua_tostring(m_pState,-1)就能够，-1代表的是以后栈的地位是绝对栈顶。固然，你也能够看看栈内里另有一些甚么其他乖僻的数据，你能够用1,2,3（这些是相对地位，而-1是绝对地位）往实验，呵呵。不外，信任你失掉的也很丢脸懂，由于一个Lua工具实行的时分，会用良多次栈举行数据互换，而你看到的，有多是互换中的数据。那末，话说返来，这句话的意义就是”[CLuaFn::LoadLuaFile]luaL_loadfile(文件名)isfile(毛病编号)(毛病详细形貌笔墨)./n”
boolCLuaFn::CallFileFn(constchar*pFunctionName,intnParam1,intnParam2)
{
intnRet=0;
if(NULL==m_pState)
{
printf(“[CLuaFn::CallFileFn]m_pStateisNULL./n”);
returnfalse;
}
lua_getglobal(m_pState,pFunctionName);
lua_pushnumber(m_pState,nParam1);
lua_pushnumber(m_pState,nParam2);
nRet=lua_pcall(m_pState,2,1,0);
if(nRet!=0)
{
printf(“[CLuaFn::CallFileFn]callfunction(%s)error(%d)./n”,pFunctionName,nRet);
returnfalse;
}
if(lua_isnumber(m_pState,-1)==1)
{
intnSum=lua_tonumber(m_pState,-1);
printf(“[CLuaFn::CallFileFn]Sum=%d./n”,nSum);
}
returntrue;
}
这个函数是，传进函数称号和参数，往你的Lua文件中往实行。
lua_getglobal(m_pState,pFunctionName);
这个函数是考证你的Lua函数是不是在你以后加载的Lua文件中，并把指针指向这个函数地位。
lua_pushnumber(m_pState,nParam1);<―对应你的x参数
lua_pushnumber(m_pState,nParam2);<―对应你的y参数
这就是出名的压栈操纵了，把你的参数压进Lua的数据栈。供Lua语法器往取得你的数据。
lua_pushnumber()是一个压进数字，lua_pushstring()是压进一个字符串。。。
那末你会问，假如我有一个本人的范例，一个类指针大概其余甚么，我怎样压进？别发急，***固然是有的，呵呵，不外你先看看假如复杂的怎样做，鄙人几讲中，我会告知你更壮大的Lua压栈艺术。
这里必要注重的是，压栈的按次，对，复杂说，就是从左到右的参数，右边的先辈栈，右侧的最初进栈。
nRet=lua_pcall(m_pState,2,1,0);
这句话的意义是，实行这个函数，2是输出参数的个数，1是输入参数的个数。固然，假如你把Lua函数改成
returnx+y,x-y;
代码必要改成nRet=lua_pcall(m_pState,2,2,0);
分明了吧，呵呵，很复杂吧。
固然，假如函数实行失利，会触发nRet，我这里偷了个懒，假如你想失掉为何错了？能够用lua_tostring(m_pState,-1)往栈顶找，分明？是否是有点感到了？
lua_isnumber(m_pState,-1)
这句话是判断栈顶的元素是否是数字。由于假如实行乐成，栈顶就应当是你的数据前往值。
intnSum=lua_tonumber(m_pState,-1);
printf(“[CLuaFn::CallFileFn]Sum=%d./n”,nSum);
这个nSum就是前往的了局。
固然，你会问，假如returnx+y,x-y;我该怎样办？
intnSum=lua_tonumber(m_pState,-1);
intnSub=lua_tonumber(m_pState,-2);
弄定，瞥见没。依照压栈按次。呵呵，是否是又有感到了，对，栈就是数据交互的中心。对Lua的了解水平和使用技能，实在就是对栈的天真使用和操纵。
好了。你的第一个Lua步伐半途而废！居然不是Helloworld，呵呵。
好了，我们看看Main函数怎样写吧，信任人人城市写。
#include“LuaFn.h”
int_tmain(intargc,_TCHAR*argv[])
{
CLuaFnLuaFn;
//LuaFn.InitClass();
LuaFn.LoadLuaFile(“Sample.lua”);
LuaFn.CallFileFn(“func_Add”,11,12);
getchar();
return0;
}
行了，Build一下，看看，是否是你要的了局？假如是，道喜你，你已迈出了Lua的第一步。
味同嚼蜡写了一个小时，喝口水吧，呵呵，下一讲，我将强化这个LuaFn类，让它给我做更多的事变。呵呵，最初，我会让你打到，用Lua文件间接画出一个Windows窗体来。并在下面画出各类按钮，列表，和复选框。是否是感到很酷？用文本往制造一个步伐？很冲动吧，恩，的确，Lua能给你做到。只需你有耐烦看下往。。。
Lua剧本在C++下的舞步（二）
上一节讲了一些基础的Lua使用，也许你会说，仍是很复杂么。呵呵，恩，是的，原本Lua就是为了让人人利用的便利快速而计划的。假如计划的过为庞大，就不会有人利用了。
上面，我要夸大一下，Lua的栈的一些观点，由于这个的确很主要，你会常常用到。纯熟利用Lua，最主要的就是要时候晓得甚么时分栈内里的数据是甚么按次，都是甚么。假如你能纯熟晓得这些，实践你已是Lua使用的妙手了。
说真的，第一次我打仗栈的时分，没有把它想的很庞大，却是看了网上良多的关于Lua的文章让我对栈的了解云里雾里，甚么元表，甚么User，甚么部分变量，甚么全局变量位移。说的那叫一个晕。自己头脑笨，了解不了这么多，也不晓得为何良多人喜好把Lua栈弄的忐忑不安，代码流畅难明。厥后其实受不了了，往Lua网站下载了Lua的文档，写的很明晰。Lua的栈实践上几句话足以。
当你初始化一个栈的时分，它的栈底是1，而栈顶绝对地位是-1，说抽象一些，你能够把栈设想成一个环，有一个指针标志以后地位，假如-1，就是以后栈顶，假如是-2就是以后栈顶后面一个参数的地位。以此类推。固然，你也能够正序往取，这里要注重，关于Lua的良多API，下标是从1入手下手的。这个和C++有些分歧。并且，在栈的下标中，负数暗示相对栈底的下标，正数暗示绝对栈顶的绝对地点，这个必定要有明晰的观点，不然很简单看晕了。
让我们看一些例子，加深了解。
lua_pushnumber(m_pState,11);
lua_pushnumber(m_pState,12);
intnIn=lua_gettop(m_pState);<C这里加了一行，lua_gettop()这个API是告知你今朝栈里元素的个数。
假如仅仅是Push两个参数，那末nIn的数值是2，对。没错。那末我们看看栈内里是怎样放的。我再加两行代码。
lua_pushnumber(m_pState,11);
lua_pushnumber(m_pState,12);
intnIn=lua_gettop(m_pState)
intnData1=lua_tonumber(m_pState,1);<C读取栈底第一个相对坐标中的元素
intnData2=lua_tonumber(m_pState,2);<C读取栈底第二个相对坐标中的元素
printf(“[Test]nData1=%d,nData2=%d./n”);
假如是你，凭直觉，告知我谜底是甚么？
如今发布谜底，看看是否是和你想的一样。
[Test]nData1=11,nData2=12
呵呵，那末，假如我把代码换成
lua_pushnumber(m_pState,11);
lua_pushnumber(m_pState,12);
intnIn=lua_gettop(m_pState)
intnData1=lua_tonumber(m_pState,-1);<C读取栈顶第一个绝对坐标中的元素
intnData2=lua_tonumber(m_pState,-2);<C读取栈顶第二个绝对坐标中的元素
printf(“[Test]nData1=%d,nData2=%d./n”);
请你告知我输入是甚么？
谜底是
[Test]nData1=12,nData2=11
呵呵，挺复杂的吧，对了，实在就这么复杂。网上别的的高阶使用，实在年夜局部都是对栈的地位举行调剂。只需你捉住次要观点，看懂仍是不难的。甚么元表，甚么变量，实在都一样，捉住中心，时候晓得栈内里的模样，就没有成绩。
好了，回到我上一节的谁人代码。
boolCLuaFn::CallFileFn(constchar*pFunctionName,intnParam1,intnParam2)
{
intnRet=0;
if(NULL==m_pState)
{
printf(“[CLuaFn::CallFileFn]m_pStateisNULL./n”);
returnfalse;
}
lua_getglobal(m_pState,pFunctionName);
lua_pushnumber(m_pState,nParam1);
lua_pushnumber(m_pState,nParam2);
intnIn=lua_gettop(m_pState);<C在这里加一行。
nRet=lua_pcall(m_pState,2,1,0);
if(nRet!=0)
{
printf(“[CLuaFn::CallFileFn]callfunction(%s)error(%d)./n”,pFunctionName,nRet);
returnfalse;
}
if(lua_isnumber(m_pState,-1)==1)
{
intnSum=lua_tonumber(m_pState,-1);
printf(“[CLuaFn::CallFileFn]Sum=%d./n”,nSum);
}
intnOut=lua_gettop(m_pState);<C在这里加一行。
returntrue;
}
nIn的谜底是几？也许你会说是2吧，呵呵，实践是3。也许你会问，为何会多一个？实在我第一次看到这个数字，也很惊奇。可是的确是3。由于你挪用的函数称号占有了一个仓库的地位。实在，在猎取nIn那一刻，仓库的模样是如许的（函数接口地点，参数1，参数2），函数称号也是一个变量进栈的。而nOut输入是1，lua_pcall()函数在挪用乐成以后，会主动的清空栈，然后把了局放进栈中。在猎取nOut的一刻，栈内是这幅摸样(输入参数1)。
这里就要再迁出一个更主要的观点了，Lua不是C++，关于C++步伐员而言，一个函数会主动创立栈，当函数实行终了后会主动清算栈，Lua可不会给你这么做，关于Lua而言，它没有函数这个观点，一个栈对应一个lua_State指针，也就是说，你必需手动往清算你不必的栈，不然会形成渣滓数据占有你的内存。
不信？那末我们来考证一下，就拿今天的代码吧，你用for轮回挪用100万次。看看nOut的输入了局。。我信任，步伐实行不到100万次就会溃散，而你的内存也会变的巨大非常。而nOut的输入也会是如许的1,2,3,4,5,6。。。。。
缘故原由就是，Lua不会扫除你之前栈内的数据，每挪用一次城市给你天生一个新的栈元素拔出个中。
那末怎样办理呢？呵呵，实在，假如不思索多线程的话，在你的函数最初加入前加一句话，就能够轻松办理这个成绩。(Lua栈操纵长短线程宁静的！)
lua_settop(m_pState,-2);
这句话的意义是甚么？lua_settop()是设置栈顶的地位，我这么写，意义就是，栈顶指针今朝在以后地位的-2的元素上。如许，我就完成了对栈的扫除。细心想一下，是否是这个事理呢？
boolCLuaFn::CallFileFn(constchar*pFunctionName,intnParam1,intnParam2)
{
intnRet=0;
if(NULL==m_pState)
{
printf(“[CLuaFn::CallFileFn]m_pStateisNULL./n”);
returnfalse;
}
lua_getglobal(m_pState,pFunctionName);
lua_pushnumber(m_pState,nParam1);
lua_pushnumber(m_pState,nParam2);
intnIn=lua_gettop(m_pState);<C在这里加一行。
nRet=lua_pcall(m_pState,2,1,0);
if(nRet!=0)
{
printf(“[CLuaFn::CallFileFn]callfunction(%s)error(%d)./n”,pFunctionName,nRet);
returnfalse;
}
if(lua_isnumber(m_pState,-1)==1)
{
intnSum=lua_tonumber(m_pState,-1);
printf(“[CLuaFn::CallFileFn]Sum=%d./n”,nSum);
}
intnOut=lua_gettop(m_pState);<C在这里加一行。
lua_settop(m_pState,-2);<C扫除不必的栈。
returntrue;
}
好了，再让我们运转100万次，看看你的步伐内存，看看你的步伐还溃散不？
假如你想打印nOut的话，输入会酿成1,1,1,1,1。。。。
最初说一句，lua_tonumber()或lua_tostring()另有今后我们要用到的lua_touserdata()必定要将数据完整掏出后保留到你的其余变量中往，不然会由于清栈操纵，招致你的步伐非常，牢记！
呵呵，说了这么多，次要是让人人怎样写一个松散的Lua步伐，不要运转没两下就溃散了。好了，基本栈的常识先说到这里，今后另有一些技能的使用，到时分会给人人展现。
上面说一下，Lua的工具。（为何要说这个呢？呵呵，由于我们下一步要用到个中的一个匡助我们的开辟。）
呵呵，实在，Lua内里有良多简化开辟的工具，你能够往http://www.sourceforge.net/往找一下。它们可以匡助你简化C++工具与Lua工具互转之间的代码。
这里说几个着名的，固然大概不全。
(luatinker)假如你的体系在windows下，并且不思索移植，那末我激烈保举你往下载一个叫做luatinker的小工具，全部工具十分复杂，一个.h和一个.cpp。间接就能够援用到你的工程中，连自力编译都不必，这是一个韩国人写的Lua与C++接口转换的类，非常便利，代码简便（居家游览，必备良药）。它是基于模板的，以是你能够很轻松的把你的C++工具绑定到Lua中。代码较长，呵呵，有乐趣的伴侣能够给我留言索要luatinker的例子。就不贴在这里了。不外我团体不保举这个器材，由于它在Linux下是编译不外往的。它利用了一种g++不撑持的模板写法，固然有人在实验把它修正到Linux下编译，但据我所知，修正后效果较好的仿佛还没有。不外假如你只是在windows下，那就没甚么可夷由的，激烈保举，你会喜好它的。
(Luabinder)信任用过Boost库的伴侣，也许对这个家伙很熟习。它是一个很壮大的Linux下Lua扩大包，帮你封装了良多Lua的庞大操纵，次要办理了绑定C++工具和Lua工具互动的干系，十分壮大，不外嘛，关于freeeyes而言，仍是不保举，由于freeeyes很懒，不想为了一个Lua还要往编译一个复杂的boost库，固然，见仁见智，假如你的步伐自己就已加载了boost，那末就应当坚决果断的选择它。
(lua++)呵呵，这是我最喜好，也是我一向用到如今的库，对照前两个而言，lua++的封装性没有那末好，良多器材仍是必要一点代码的，不外之以是我喜好，是由于它是用C写的，能够在windows下和linux下轻松转换。假如鱼与熊掌不克不及兼得，那末我宁肯选择一个分身二者的器材，假如有的话，呵呵。固然，lua++就是这么一个器材，假如你持续看我的文章，也许你也会喜好它的。
好了，空话少说，就让我选择lua++作为我们持续举行下往的垫脚石吧。
说到Lua++(http://www.codenix.com/~tolua/)，这个器材仍是挺有渊源的，请你先下载一个。我教你怎样编译。
还记得我今天说过怎样编译Lua么，如今请你再做一遍，分歧的是，请把lua++的步伐包中的src/lib中的一切h和cpp，另有include下的谁人.h拷贝到你前次创建的lua工程中。然后全体增加到你的静态链接库工程中往，从头编译。会天生一个新的lua.lib，这个lua就主动包括了lua++的功效。最初记得把tolua++.h放在你的Include文件夹下。
行了，我们把前次CLuaFn类略微改一下。
extern“C”
{
#include“lua.h”
#include“lualib.h”
#include“lauxlib.h”
#include“tolua++”//这里加一行
};
classCLuaFn
{
public:
CLuaFn(void);
~CLuaFn(void);
voidInit();//初始化Lua工具指针参数
voidClose();//封闭Lua工具指针
boolLoadLuaFile(constchar*pFileName);//加载指定的Lua文件
boolCallFileFn(constchar*pFunctionName,intnParam1,intnParam2);//实行指定Lua文件中的函数
private:
lua_State*m_pState;//这个是Lua的State工具指针，你能够一个lua文件对应一个。
};
行了，如许我们就可以用Lua++下的功效了。
今天，人人看到了boolCallFileFn(constchar*pFunctionName,intnParam1,intnParam2);这个函数的使用。演示了真么挪用Lua函数。
上面，我改一下，这个函数。为何？仍是由于freeeyes很懒，我可不想每有一个函数，我都要写一个C++函数往挪用，太累！我要写一个通用的！撑持恣意函数挪用的接口！
因而我创立了两个类。撑持恣意参数的输出和输入，并打包送给lua往实行，说干就干。
#ifndef_PARAMDATA_H
#define_PARAMDATA_H
#include<vector>
#defineMAX_PARAM_200200
usingnamespacestd;
struct_ParamData
{
public:
void*m_pParam;
charm_szType[MAX_PARAM_200];
intm_TypeLen;
public:
_ParamData()
{
m_pParam=NULL;
m_szType[0]=‘/0′;
m_TypeLen=0;
};
_ParamData(void*pParam,constchar*szType,intnTypeLen)
{
SetParam(pParam,szType,nTypeLen);
}
~_ParamData(){};
voidSetParam(void*pParam,constchar*szType,intnTypeLen)
{
m_pParam=pParam;
sprintf(m_szType,“%s”,szType);
m_TypeLen=nTypeLen;
};
boolSetData(void*pParam,intnLen)
{
if(m_TypeLen<nLen)
{
returnfalse;
}
if(nLen>0)
{
memcpy(m_pParam,pParam,nLen);
}
else
{
memcpy(m_pParam,pParam,m_TypeLen);
}
returntrue;
}
void*GetParam()
{
returnm_pParam;
}
constchar*GetType()
{
returnm_szType;
}
boolCompareType(constchar*pType)
{
if(0==strcmp(m_szType,pType))
{
returntrue;
}
else
{
returnfalse;
}
}
};
classCParamGroup
{
public:
CParamGroup(){};
~CParamGroup()
{
Close();
};
voidInit()
{
m_vecParamData.clear();
};
voidClose()
{
for(inti=0;i<(int)m_vecParamData.size();i++)
{
_ParamData*pParamData=m_vecParamData;
deletepParamData;
pParamData=NULL;
}
m_vecParamData.clear();
};
voidPush(_ParamData*pParam)
{
if(pParam!=NULL)
{
m_vecParamData.push_back(pParam);
}
};
_ParamData*GetParam(intnIndex)
{
if(nIndex<(int)m_vecParamData.size())
{
returnm_vecParamData[nIndex];
}
else
{
returnNULL;
}
};
intGetCount()
{
return(int)m_vecParamData.size();
}
private:
typedefvector<_ParamData*>vecParamData;
vecParamDatam_vecParamData;
};
#endif
#endif
我创立了两个类，把Lua要用到的范例，数据都封装起来了。如许，我只必要这么改写这个函数。
boolCallFileFn(constchar*pFunctionName,CParamGroup&ParamIn,CParamGroup&ParamOut);
它就可以依照分歧的参数主动给我挪用，嘿嘿，懒抵家吧！
实在这两个类很复杂，_ParamData是参数类，把你要用到的参数放进到这个工具中往，标明范例的巨细，范例称号，内存块。而CParamGroup卖力将良多良多的_ParamData打包在一同，放在vector内里。
好了，让我们看看CallFileFn函数内里我怎样改的。
boolCLuaFn::CallFileFn(constchar*pFunctionName,CParamGroup&ParamIn,CParamGroup&ParamOut)
{
intnRet=0;
inti=0;
if(NULL==m_pState)
{
printf(“[CLuaFn::CallFileFn]m_pStateisNULL./n”);
returnfalse;
}
lua_getglobal(m_pState,pFunctionName);
//加载输出参数
for(i=0;i<ParamIn.GetCount();i++)
{
PushLuaData(m_pState,ParamIn.GetParam(i));
}
nRet=lua_pcall(m_pState,ParamIn.GetCount(),ParamOut.GetCount(),0);
if(nRet!=0)
{
printf(“[CLuaFn::CallFileFn]callfunction(%s)error(%s)./n”,pFunctionName,lua_tostring(m_pState,-1));
returnfalse;
}
//取得输入参数
intnPos=0;
for(i=ParamOut.GetCount()C1;i>=0;iC)
{
nPosC;
PopLuaData(m_pState,ParamOut.GetParam(i),nPos);
}
intnCount=lua_gettop(m_pState);
lua_settop(m_pState,-1-ParamOut.GetCount());
returntrue;
}
呵呵，其余没变，加了两个轮回，由于思索lua是能够撑持多了局前往的，以是我也做了一个轮回承受参数。
lua_settop(m_pState,-1-ParamOut.GetCount());这句话是否是有些意义，恩，是的，我这里做了一个小技能，由于我不晓得前往参数有几个，以是我会依据前往参数的个数从头设置栈顶。如许做能够前往恣意数目的栈并且扫除洁净。
也许仔细的你已发明，内里多了两个函数。恩，是的。来看看这两个函数在干甚么。
boolCLuaFn::PushLuaData(lua_State*pState,_ParamData*pParam)
{
if(pParam==NULL)
{
returnfalse;
}
if(pParam->CompareType(“string”))
{
lua_pushstring(m_pState,(char*)pParam->GetParam());
returntrue;
}
if(pParam->CompareType(“int”))
{
int*nData=(int*)pParam->GetParam();
lua_pushnumber(m_pState,*nData);
returntrue;
}
else
{
void*pVoid=pParam->GetParam();
tolua_pushusertype(m_pState,pVoid,pParam->GetType());
returntrue;
}
}
参数进栈操纵，呵呵，也许你会问tolua_pushusertype(m_pState,pVoid,pParam->GetType());这句话，你大概有些看不懂，不妨，我会鄙人一讲具体的注释Lua++的一些API的用法。如今也许和你说一下，这句话的意义就是，把一个C++工具传输给Lua函数。
再看看，上面一个。
boolCLuaFn::PopLuaData(lua_State*pState,_ParamData*pParam,intnIndex)
{
if(pParam==NULL)
{
returnfalse;
}
if(pParam->CompareType(“string”))
{
if(lua_isstring(m_pState,nIndex)==1)
{
constchar*pData=(constchar*)lua_tostring(m_pState,nIndex);
pParam->SetData((void*)pData,(int)strlen(pData));
}
returntrue;
}
if(pParam->CompareType(“int”))
{
if(lua_isnumber(m_pState,nIndex)==1)
{
intnData=(int)lua_tonumber(m_pState,nIndex);
pParam->SetData(&nData,sizeof(int));
}
returntrue;
}
else
{
pParam->SetData(tolua_tousertype(m_pState,nIndex,NULL),-1);
returntrue;
}
}
弹出一个参数并赋值。pParam->SetData(tolua_tousertype(m_pState,nIndex,NULL),-1);这句话一样，我鄙人一讲中具体先容。
呵呵，好了，我们又进了一步，我们能够用这个函数绑定恣意一个Lua函数格局。而代码不必多写，懒蛋的目标到达了。
呵呵，这一讲次要是先容了一些基础常识，也许有点过剩，可是我以为是需要的，鄙人一讲中，我讲入手下手具体先容怎样绑定一个C++工具给Lua，并让Lua对其修正。然后前往了局。歇息一下，歇息一下先。
Lua剧本在C++下的舞步（三）
上一讲我把Lua基础的栈划定规矩讲了一下，然后完美了一下我的CLuaFn类。让它能够撑持恣意参数数目和函数称号的传值。固然，这些功效是为了明天这篇文章而展路的。
看了七猫的回帖，呵呵，的确应当说一下SWIG这个工具，说真的，我对这个工具了解不深，由于没有怎样用过，读过一些关于它的文章，仿佛是帮你把C++的功效封装成一个Lua基础库的器材，可是厥后研讨，他能够很轻松帮你把公用函数封装成一个Lua的基础库(相似C++的dll)，可是关于我的需求而言，大概不太一样。由于我大批的是必要在C++内里举行数据传输和变量的交互，以是为了紧贴C++，我必要良多联系关系数据的处置。
我是一位C++步伐员，以是在良多时分，不想过量的利用Lua的特征，由于团体感到，Lua的语法要比C++的加倍天真。而我更但愿，在函数挪用的某些习气上，遵守一些C++的划定规矩。
好了，空话少说，我们先来看一个类（头文件）。假定我们要把这个工具，传输给Lua举行挪用。
#ifndef_TEST_H
#define_TEST_H
classCTest
{
public:
CTest(void);
~CTest(void);
char*GetData();
voidSetData(constchar*pData);
private:
charm_szData[200];
};
#endif
这个类内里有两个函数，一个是GetData()，一个是SetData()，之以是这么写，我要让Lua不但能利用我的类，还能够给这个类利用参数。
那末，cpp文件，我们临时如许写。（固然，你能够举行修正，依照你喜好的体例写一个***，呵呵）
char*CTest::GetData()
{
printf(“[CTest::GetData]%s./n”,m_szData);
returnm_szData;
}
voidCTest::SetData(constchar*pData)
{
sprintf(m_szData,“%s”,pData);
}
这是一个尺度的类，我必要这个类在Lua内里能够制造出来，并付与数值，乃至我能够把CTest作为一个Lua函数参数，传给Lua函数让它往给我处置。让我们来看看怎样做。假如利用尺度的Lua语法，有点多，以是我就借用一下前次提到的tolua来做到这统统，我一句句的注释。临时我们把这些代码放在LuaFn.cpp内里。
staticinttolua_new_CTest(lua_State*pState)
{
CTest*pTest=newCTest();
tolua_pushusertype(pState,pTest,“CTest”);
return1;
}
staticinttolua_delete_CTest(lua_State*pState)
{
CTest*pTest=(CTest*)tolua_tousertype(pState,1,0);
if(NULL!=pTest)
{
deletepTest;
}
return1;
}
staticinttolua_SetData_CTest(lua_State*pState)
{
CTest*pTest=(CTest*)tolua_tousertype(pState,1,0);
constchar*pData=tolua_tostring(pState,2,0);
if(pData!=NULL&&pTest!=NULL)
{
pTest->SetData(pData);
}
return1;
}
staticinttolua_GetData_CTest(lua_State*pState)
{
CTest*pTest=(CTest*)tolua_tousertype(pState,1,0);
if(pTest!=NULL)
{
char*pData=pTest->GetData();
tolua_pushstring(pState,pData);
}
return1;
}
看看这几个静态函数在干甚么。
我要在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***内里存在变量，那末一样，我们必要利用constchar*pData=tolua_tostring(pState,2,0);将参数弹出来，然后输出到pTest->SetData(pData);工具中往，固然，你能够有更多多少个参数。随你的喜欢。这里只做一个举例。
好了，你必定会问，这么多的静态函数，用在那里？呵呵，固然是给Lua注册，当你把这些数据注册到Lua内里，你就能够轻松的在Lua中利用它们。
让我们看看，注册是怎样做到的。
仍是在CLuaFn类内里，我们增添一个函数。好比叫做boolInitClass();
boolCLuaFn::InitClass()
{
if(NULL==m_pState)
{
printf(“[CLuaFn::InitClass]m_pStateisNULL./n”);
returnfalse;
}
tolua_open(m_pState);
tolua_module(m_pState,NULL,0);
tolua_beginmodule(m_pState,NULL);
tolua_usertype(m_pState,“CTest”);
tolua_cclass(m_pState,“CTest”,“CTest”,“”,tolua_delete_CTest);
tolua_beginmodule(m_pState,“CTest”);
tolua_function(m_pState,“new”,tolua_new_CTest);
tolua_function(m_pState,“SetData”,tolua_SetData_CTest);
tolua_function(m_pState,“GetData”,tolua_GetData_CTest);
tolua_endmodule(m_pState);
tolua_endmodule(m_pState);
returntrue;
}
下面的代码，就是我把下面的几个静态函数，绑定到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的文件么。我们来改一下它。
functionfunc_Add(x,y)
localtest=CTest:new();
test:SetData(“I’mfreeeyes!”);
test:GetData();
returnx..y;
end
我在这个函数内里，New了一个CTest工具，并举行赋值操纵，最初把了局打印在屏幕上。你也许会问，最初一句不是x+y么，怎样酿成了x..y，呵呵，在Lua中，..暗示团结的意义，就比如在C++内里，stringstrName+=“freeeyes”。本来以为x+y有点土，干脆前往一个两个字符串的团结吧。
好了，我们已把我们的这个CTest类注册到了Lua内里，让我们来挪用一下吧。修正一下Main函数。酿成以下的模样。
int_tmain(intargc,_TCHAR*argv[])
{
CLuaFnLuaFn;
LuaFn.InitClass();
LuaFn.LoadLuaFile(“Sample.lua”);
CParamGroupParamIn;
CParamGroupParamOut;
charszData1[20]={‘/0′};
sprintf(szData1,“[freeeyes]“);
_ParamData*pParam1=new_ParamData(szData1,“string”,(int)strlen(szData1));
ParamIn.Push(pParam1);
charszData2[20]={‘/0′};
sprintf(szData2,“[shiqiang]“);
_ParamData*pParam2=new_ParamData(szData2,“string”,(int)strlen(szData2));
ParamIn.Push(pParam2);
charszData3[40]={‘/0′};
_ParamData*pParam3=new_ParamData(szData3,“string”,40);
ParamOut.Push(pParam3);
LuaFn.CallFileFn(“func_Add”,ParamIn,ParamOut);
char*pData=(char*)ParamOut.GetParam(0)->GetParam();
printf(“[Main]Sum=%s./n”,pData);
getchar();
return0;
}
假如你完整依照我的，你就能够编译你的工程了，运转一下，看看是啥了局？
[CTest::GetData]I’mfreeeyes!.
[Main]Sum=[freeeyes][shiqiang].
看看，是否是和我输入的一样？
呵呵，成心思吧，你已能够在Lua内里用C++的函数了，那末我们再增添一点难度，好比，我有一个CTest工具，要作为一个参数，传输给func_Add()实行，怎样办？
很复杂，假如你对下面的代码细心浏览，你会发明上面的代码一样简便。为了撑持方才要说的需求，我们必要把Sample.lua再做一点修正。
functionfunc_Add(x,y,f)
f:SetData(“I’mfreeeyes!”);
f:GetData();
returnx..y;
end
f假定就是我们要传进的CTest工具。我们要在Lua内里利用它。（我们的CLuaFn都不必改，把main函数略微改一下便可，来看看怎样写。）
//LuaSample.cpp:界说把持台使用步伐的出口点。
//
#include“stdafx.h”
#include“LuaFn.h”
int_tmain(intargc,_TCHAR*argv[])
{
CLuaFnLuaFn;
LuaFn.InitClass();
LuaFn.LoadLuaFile(“Sample.lua”);
CParamGroupParamIn;
CParamGroupParamOut;
charszData1[20]={‘/0′};
sprintf(szData1,“[freeeyes]“);
_ParamData*pParam1=new_ParamData(szData1,“string”,(int)strlen(szData1));
ParamIn.Push(pParam1);
charszData2[20]={‘/0′};
sprintf(szData2,“[shiqiang]“);
_ParamData*pParam2=new_ParamData(szData2,“string”,(int)strlen(szData2));
ParamIn.Push(pParam2);
//只追加了这里
CTest*pTest=newCTest();
_ParamData*pParam3=new_ParamData(pTest,“CTest”,sizeof(CTest));
ParamIn.Push(pParam3);
//追加停止
charszData4[40]={‘/0′};
_ParamData*pParam4=new_ParamData(szData4,“string”,40);
ParamOut.Push(pParam4);
LuaFn.CallFileFn(“func_Add”,ParamIn,ParamOut);
char*pData=(char*)ParamOut.GetParam(0)->GetParam();
printf(“[Main]Sum=%s./n”,pData);
getchar();
return0;
}
好了，就这么点代码，改好了，我们再Build一下，然后点击运转。看看输入了局，是否是和之前的一样？
恩，是否是有点镇静了？你乐成的让Lua入手下手挪用你的C++工具了！而且依照你要的体例实行！还记得我曾在第一篇文章内里允诺过，我会让你画出一个MFC窗体么？呵呵，假如你到如今仍然以为很明晰的话，申明你的间隔已不远了。
既然已到了这里，我们干脆再加点难度，假如我要把CTest作为一个工具前往返来怎样做？很复杂，且看。
int_tmain(intargc,_TCHAR*argv[])
{
CLuaFnLuaFn;
LuaFn.InitClass();
LuaFn.LoadLuaFile(“Sample.lua”);
CParamGroupParamIn;
CParamGroupParamOut;
charszData1[20]={‘/0′};
sprintf(szData1,“[freeeyes]“);
_ParamData*pParam1=new_ParamData(szData1,“string”,(int)strlen(szData1));
ParamIn.Push(pParam1);
charszData2[20]={‘/0′};
sprintf(szData2,“[shiqiang]“);
_ParamData*pParam2=new_ParamData(szData2,“string”,(int)strlen(szData2));
ParamIn.Push(pParam2);
CTest*pTest=newCTest();
_ParamData*pParam3=new_ParamData(pTest,“CTest”,sizeof(CTest));
ParamIn.Push(pParam3);
CTest*pTestRsult=NULL;
_ParamData*pParam4=new_ParamData(pTestRsult,“CTest”,sizeof(pTestRsult));
ParamOut.Push(pParam4);
LuaFn.CallFileFn(“func_Add”,ParamIn,ParamOut);
//承受Lua前往参数为CTest范例，并挪用个中的***。
pTestRsult=(CTest*)ParamOut.GetParam(0)->GetParam();
pTestRsult->GetData();
getchar();
return0;
}
好，编译，实行。呵呵，看到了吧。
看到这里，假如你能看的分明，申明你已对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剧本把它画出来，作为最初的磨练，呵呵。


附带全体工程（附带Lua及tolua++）

登录/注册后可看大图

HelloLua_01_03.rar


欢迎大家来到仓酷云论坛！

硬盘安装及光盘安装，清楚了解安装Linux应注意的有关问题，如安装Linux应在最后一个分区内，至少分二个分区。

眼看这个学期的Linux课程已经告一段落了，我觉得有必要写一遍心得体会来总结一下这学期对着门课程的学习。

首先Linux是开源的，这也是最主要的原因，想学windows，Unix，对不起我们没源代码。也正是因为这样，Linux才能够像滚雪球一样越滚越大，发展到现在这种规模。

尽我能力帮助他人，在帮助他人的同时你会深刻巩固知识。

写学习日记，这是学习历程的见证，同时我坚持认为是增强学习信念的法宝。

学习Linux半年了~个人认为不会的多在网上找资料网上有很多资料可以搜索到,LS那位说放手去搞。

放手去搞。尽量不要提问，运用搜索找答案，或者看wiki，从原理上理解操作系统的本质，而不是满足于使用几个技巧。尽量看英文资料。

我是学习嵌入式方向的，这学期就选修了这门专业任选课。