Lua和C++交互总结（很详细）

概述出处：http://blog.csdn.net/shun_fzll/article/details/39120965 一.lua堆栈 要理解lua和c++交互，首先要理解lua堆栈。 简单来说，Lua和C/c++语言通信的主要方法是一个无处不在的虚拟栈。栈的特点是先进后出。 在lua中，lua堆栈就是一个struct，堆栈索引的方式可是是正数也可以是负数，区别是：正数索引1永远表示栈底，负数索引-

出处：http://blog.csdn.net/shun_fzll/article/details/39120965

一.lua堆栈

要理解lua和c++交互，首先要理解lua堆栈。

简单来说，Lua和C/c++语言通信的主要方法是一个无处不在的虚拟栈。栈的特点是先进后出。

在lua中，lua堆栈就是一个struct，堆栈索引的方式可是是正数也可以是负数，区别是：正数索引1永远表示栈底，负数索引-1永远表示栈顶。如图：

二.堆栈的 *** 作

因为lua与c/c++是通过栈来通信，lua提供了C API对栈进行 *** 作。

我们先来看一个最简单的例子：

[cpp] view plain copy print ? #include <iostream>   #include <string.h>   using namespace std;      extern "C"   {       #include "lua.h"       #include "lauxlib.h"       #include "lualib.h"   }   voID main()   {       //1.创建一个state       lua_State *L = luaL_newstate();              //2.入栈 *** 作       lua_pushstring(L, "I am so cool~");        lua_pushnumber(L,20);          //3.取值 *** 作       if( lua_isstring(L,1)){             //判断是否可以转为string           cout<<lua_tostring(L,1)<<endl;  //转为string并返回       }       if( lua_isnumber(L,2)){           cout<<lua_tonumber(L,2)<<endl;       }          //4.关闭state       lua_close(L);       return ;   }  

#include <iostream>#include <string.h>using namespace std;extern "C"{	#include "lua.h"	#include "lauxlib.h"	#include "lualib.h"}voID main(){	//1.创建一个state	lua_State *L = luaL_newstate();		//2.入栈 *** 作	lua_pushstring(L,"I am so cool~"); 	lua_pushnumber(L,20);	//3.取值 *** 作	if( lua_isstring(L,1)){            	//判断是否可以转为string		cout<<lua_tostring(L,1)<<endl;	//转为string并返回	}	if( lua_isnumber(L,2)){		cout<<lua_tonumber(L,2)<<endl;	}	//4.关闭state	lua_close(L);	return ;}

可以简单理解为luaL_newstate返回一个指向堆栈的指针，其它看注释应该能懂了吧。

如果对extern "C"不熟悉的可以点击这里：http://www.voidcn.com/article/p-ryespimv-rq.html。

其他一些栈 *** 作：

[cpp] view plain copy print ? int   lua_gettop (lua_State *L);            //返回栈顶索引（即栈长度）   voID  lua_settop (lua_State *L, int IDx);   //                 voID  lua_pushvalue (lua_State *L, int IDx);//将IDx索引上的值的副本压入栈顶   voID  lua_remove (lua_State *L, int IDx);   //移除IDx索引上的值   voID  lua_insert (lua_State *L, int IDx);   //d出栈顶元素，并插入索引IDx位置   voID  lua_replace (lua_State *L, int IDx);  //d出栈顶元素，并替换索引IDx位置的值  

int   lua_gettop (lua_State *L);			//返回栈顶索引（即栈长度）voID  lua_settop (lua_State *L,int IDx);	//				voID  lua_pushvalue (lua_State *L,int IDx);//将IDx索引上的值的副本压入栈顶voID  lua_remove (lua_State *L,int IDx);	//移除IDx索引上的值voID  lua_insert (lua_State *L,int IDx);	//d出栈顶元素，并插入索引IDx位置voID  lua_replace (lua_State *L,int IDx);	//d出栈顶元素，并替换索引IDx位置的值

lua_settop将栈顶设置为一个指定的位置，即修改栈中元素的数量。如果值比原栈顶高，则高的部分nil补足，如果值比原栈低，则原栈高出的部分舍弃。

所以可以用lua_settop(0)来清空栈。

三.c++调用lua

我们经常可以使用lua文件来作配置文件。类似ini，xml等文件配置信息。
现在我们来使用c++来读取lua文件中的变量，table，函数。

现在有这样一个hello.lua 文件：

[cpp] view plain copy print ? str = "I am so cool"   tbl = {name = "shun", ID = 20114442}   function add(a,b)       return a + b   end  

str = "I am so cool"tbl = {name = "shun",ID = 20114442}function add(a,b)	return a + bend

我们写一个test.cpp来读取它：

[cpp] view plain copy print ? #include <iostream>   #include <string.h>   using namespace std;      extern "C"   {       #include "lua.h"       #include "lauxlib.h"       #include "lualib.h"   }   voID main()   {       //1.创建Lua状态       lua_State *L = luaL_newstate();       if (L == NulL)       {           return ;       }          //2.加载lua文件       int bRet = luaL_loadfile(L,"hello.lua");       if(bRet)       {           cout<<"load file error"<<endl;           return ;       }          //3.运行lua文件       bRet = lua_pcall(L,0);       if(bRet)       {           cout<<"pcall error"<<endl;           return ;       }          //4.读取变量       lua_getglobal(L,"str");       string str = lua_tostring(L,-1);       cout<<"str = "<<str.c_str()<<endl;        //str = I am so cool~          //5.读取table       lua_getglobal(L,"tbl");        lua_getfIEld(L,-1,"name");       str = lua_tostring(L,-1);       cout<<"tbl:name = "<<str.c_str()<<endl; //tbl:name = shun          //6.读取函数       lua_getglobal(L, "add");        // 获取函数，压入栈中       lua_pushnumber(L, 10);          // 压入第一个参数       lua_pushnumber(L, 20);          // 压入第二个参数       int iRet= lua_pcall(L, 2, 1, 0);// 调用函数，调用完成以后，会将返回值压入栈中，2表示参数个数，1表示返回结果个数。       if (iRet)                       // 调用出错       {           const char *pErrorMsg = lua_tostring(L, -1);           cout << pErrorMsg << endl;           lua_close(L);           return ;       }       if (lua_isnumber(L, -1))        //取值输出       {           double fValue = lua_tonumber(L, -1);           cout << "Result is " << fValue << endl;       }          //至此，栈中的情况是：       //=================== 栈顶 ===================        //  索引  类型      值       //   4   int：      30        //   3   string：   shun        //   2   table:     tbl       //   1   string:    I am so cool~       //=================== 栈底 ===================           //7.关闭state       lua_close(L);       return ;   }  

#include <iostream>#include <string.h>using namespace std;extern "C"{	#include "lua.h"	#include "lauxlib.h"	#include "lualib.h"}voID main(){	//1.创建Lua状态	lua_State *L = luaL_newstate();	if (L == NulL)	{		return ;	}	//2.加载lua文件	int bRet = luaL_loadfile(L,"hello.lua");	if(bRet)	{		cout<<"load file error"<<endl;		return ;	}	//3.运行lua文件	bRet = lua_pcall(L,0);	if(bRet)	{		cout<<"pcall error"<<endl;		return ;	}	//4.读取变量	lua_getglobal(L,"str");	string str = lua_tostring(L,-1);	cout<<"str = "<<str.c_str()<<endl;		//str = I am so cool~	//5.读取table	lua_getglobal(L,"tbl"); 	lua_getfIEld(L,"name");	str = lua_tostring(L,-1);	cout<<"tbl:name = "<<str.c_str()<<endl; //tbl:name = shun	//6.读取函数	lua_getglobal(L,"add");		// 获取函数，压入栈中	lua_pushnumber(L,10);			// 压入第一个参数	lua_pushnumber(L,20);			// 压入第二个参数	int iRet= lua_pcall(L,2,1,0);// 调用函数，调用完成以后，会将返回值压入栈中，2表示参数个数，1表示返回结果个数。	if (iRet)						// 调用出错	{		const char *pErrorMsg = lua_tostring(L,-1);		cout << pErrorMsg << endl;		lua_close(L);		return ;	}	if (lua_isnumber(L,-1))        //取值输出	{		double fValue = lua_tonumber(L,-1);		cout << "Result is " << fValue << endl;	}	//至此，栈中的情况是：	//=================== 栈顶 =================== 	//  索引  类型      值	//   4   int：      30 	//   3   string：   shun 	//	 2	 table:		tbl	//   1   string:	I am so cool~	//=================== 栈底 =================== 	//7.关闭state	lua_close(L);	return ;}

知道怎么读取后，我们来看下如何修改上面代码中table的值：

[cpp] view plain copy print ? // 将需要设置的值设置到栈中   lua_pushstring(L, "我是一个大帅锅～");   // 将这个值设置到table中（此时tbl在栈的位置为2）   lua_setfIEld(L, "name");  

// 将需要设置的值设置到栈中lua_pushstring(L,"我是一个大帅锅～");// 将这个值设置到table中（此时tbl在栈的位置为2）lua_setfIEld(L,"name");

我们还可以新建一个table：

[cpp] view plain copy print ? // 创建一个新的table，并压入栈   lua_newtable(L);   // 往table中设置值   lua_pushstring(L, "Give me a girl frIEnd !"); //将值压入栈   lua_setfIEld(L, -2, "str"); //将值设置到table中，并将Give me a girl frIEnd 出栈  

// 创建一个新的table，并压入栈lua_newtable(L);// 往table中设置值lua_pushstring(L,"Give me a girl frIEnd !"); //将值压入栈lua_setfIEld(L,-2,"str"); //将值设置到table中，并将Give me a girl frIEnd 出栈

需要注意的是：堆栈 *** 作是基于栈顶的，就是说它只会去 *** 作栈顶的值。

举个比较简单的例子，函数调用流程是先将函数入栈，参数入栈，然后用lua_pcall调用函数，此时栈顶为参数，栈底为函数，所以栈过程大致会是：参数出栈->保存参数->参数出栈->保存参数->函数出栈->调用函数->返回结果入栈。

类似的还有lua_setfIEld，设置一个表的值，肯定要先将值出栈，保存，再去找表的位置。

再不理解可看如下例子：

[cpp] view plain copy print ? lua_getglobal(L, "add");        // 获取函数，压入栈中   lua_pushnumber(L, 10);          // 压入第一个参数   lua_pushnumber(L, 20);          // 压入第二个参数   int iRet= lua_pcall(L, 0);// 将2个参数出栈，函数出栈，压入函数返回结果      lua_pushstring(L, "我是一个大帅锅～");  //    lua_setfIEld(L, "name");             // 会将"我是一个大帅锅～"出栈  

lua_getglobal(L,"add");		// 获取函数，压入栈中lua_pushnumber(L,10);			// 压入第一个参数lua_pushnumber(L,20);			// 压入第二个参数int iRet= lua_pcall(L,0);// 将2个参数出栈，函数出栈，压入函数返回结果lua_pushstring(L,"我是一个大帅锅～");  // lua_setfIEld(L,"name");             // 会将"我是一个大帅锅～"出栈

另外补充一下：

lua_getglobal(L,"var")会执行两步 *** 作：1.将var放入栈中，2.由lua去寻找变量var的值，并将变量var的值返回栈顶（替换var）。
lua_getfIEld(L,"name") 的作用等价于 lua_pushstring(L,"name") + lua_gettable(L,-2)

四.lua调用c++

我们分三个方法实现它。

方法一：直接将模块写入lua源码中

在lua中调用c/c++，我们可以将函数写lua.c中，然后重新编译lua文件。
也许你用的是Lua for Windows集成环境，没关系，不会编译lua可以参考这篇：http://www.voidcn.com/article/p-udltfdcf-bdk.html

编译好后是这样子的：（如图）

然后我们可以在lua.c中加入我们自己的函数。函数要遵循规范（可在lua.h中查看）如下：

[cpp] view plain copy print ? typedef int (*lua_CFunction) (lua_State *L);  

typedef int (*lua_CFunction) (lua_State *L);

换句话说，所有的函数必须接收一个lua_State作为参数，同时返回一个整数值。因为这个函数使用Lua栈作为参数，所以它可以从栈里面读取任意数量和任意类型的参数。而这个函数的返回值则表示函数返回时有多少返回值被压入Lua栈。（因为Lua的函数是可以返回多个值的）


然后我们在lua.c中加入如下函数：

[cpp] view plain copy print ? // This is my function   static int getTwoVar(lua_State *L)   {       // 向函数栈中压入2个值       lua_pushnumber(L, 10);       lua_pushstring(L,"hello");          return 2;   }  

// This is my functionstatic int getTwoVar(lua_State *L){    // 向函数栈中压入2个值    lua_pushnumber(L,10);    lua_pushstring(L,"hello");    return 2;}

在pmain函数中，luaL_openlibs函数后加入以下代码：

[cpp] view plain copy print ? //注册函数   lua_pushcfunction(L, getTwoVar); //将函数放入栈中   lua_setglobal(L, "getTwoVar");   //设置lua全局变量getTwoVar  

//注册函数lua_pushcfunction(L,getTwoVar); //将函数放入栈中lua_setglobal(L,"getTwoVar");   //设置lua全局变量getTwoVar

通过查找lua.h

[cpp] view plain copy print ? /#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))  

/#define lua_register(L,f) (lua_pushcfunction(L,(f)),lua_setglobal(L,(n)))

我们发现之前的注册函数可以这样子写：

[cpp] view plain copy print ? lua_register(L,"getTwoVar",getTwoVar);  

lua_register(L,"getTwoVar",getTwoVar);

运行，结果如图：

当然，一般我们不建议去修改别人的代码，更倾向于自己编写独立的c/c++模块，供lua调用，下面来讲讲如何实现。

方法二：使用静态依赖的方式

1.新建一个空的win32控制台工程，记得在vc++目录中，把lua中的头文件和lib文件的目录包含进来，然后->链接器->附加依赖项->将lua51.lib和lua5.1.lib也包含进来。

2.在目录下新建一个avg.lua如下：

[cpp] view plain copy print ? avg, sum = average(10, 20, 30, 40, 50)   print("The average is ", avg)   print("The sum is ", sum)  

avg,sum = average(10,20,30,40,50)print("The average is ",avg)print("The sum is ",sum)

3.新建test.cpp如下：

[cpp] view plain copy print ? #include <stdio.h>      extern "C" {   #include "lua.h"   #include "lualib.h"   #include "lauxlib.h"   }      /* 指向Lua解释器的指针 */   lua_State* L;   static int average(lua_State *L)   {       /* 得到参数个数 */       int n = lua_gettop(L);       double sum = 0;       int i;          /* 循环求参数之和 */       for (i = 1; i <= n; i++)       {           /* 求和 */           sum += lua_tonumber(L, i);       }       /* 压入平均值 */       lua_pushnumber(L, sum / n);       /* 压入和 */       lua_pushnumber(L, sum);       /* 返回返回值的个数 */       return 2;   }      int main ( int argc, char *argv[] )   {       /* 初始化Lua */       L = lua_open();          /* 载入Lua基本库 */       luaL_openlibs(L);       /* 注册函数 */       lua_register(L, "average", average);       /* 运行脚本 */       luaL_dofile(L, "avg.lua");       /* 清除Lua */       lua_close(L);          /* 暂停 */       printf( "Press enter to exit…" );       getchar();       return 0;   }  

#include <stdio.h>extern "C" {#include "lua.h"#include "lualib.h"#include "lauxlib.h"}/* 指向Lua解释器的指针 */lua_State* L;static int average(lua_State *L){	/* 得到参数个数 */	int n = lua_gettop(L);	double sum = 0;	int i;	/* 循环求参数之和 */	for (i = 1; i <= n; i++)	{		/* 求和 */		sum += lua_tonumber(L,i);	}	/* 压入平均值 */	lua_pushnumber(L,sum / n);	/* 压入和 */	lua_pushnumber(L,sum);	/* 返回返回值的个数 */	return 2;}int main ( int argc,char *argv[] ){	/* 初始化Lua */	L = lua_open();	/* 载入Lua基本库 */	luaL_openlibs(L);	/* 注册函数 */	lua_register(L,"average",average);	/* 运行脚本 */	luaL_dofile(L,"avg.lua");	/* 清除Lua */	lua_close(L);	/* 暂停 */	printf( "Press enter to exit…" );	getchar();	return 0;}

执行一下，我们可以得到结果：

大概顺序就是：我们在c++中写一个模块函数，将函数注册到lua解释器中，然后由c++去执行我们的lua文件，然后在lua中调用刚刚注册的函数。

看上去很别扭啊有木有。。。接下来介绍一下dll调用方式。

方法三：使用dll动态链接的方式

我们先新建一个dll工程，工程名为mLualib。（因此最后导出的dll也为mLualib.dll）

然后编写我们的c++模块，以函数为例，我们先新建一个.h文件和.cpp文件。

h文件如下：（如果你不是很能明白头文件的内容，点击这里：http://www.voidcn.com/article/p-ryespimv-rq.html。）

[cpp] view plain copy print ? #pragma once      extern "C" {   #include "lua.h"   #include "lualib.h"   #include "lauxlib.h"   }      #ifdef LUA_EXPORTS   #define LUA_API __declspec(dllexport)   #else   #define LUA_API __declspec(dllimport)   #endif      extern "C" LUA_API int luaopen_mLualib(lua_State *L);//定义导出函数  

#pragma onceextern "C" {#include "lua.h"#include "lualib.h"#include "lauxlib.h"}#ifdef LUA_EXPORTS#define LUA_API __declspec(dllexport)#else#define LUA_API __declspec(dllimport)#endifextern "C" LUA_API int luaopen_mLualib(lua_State *L);//定义导出函数

.cpp文件如下：

[cpp] view plain copy print ? #include <stdio.h>   #include "mLualib.h"      static int averageFunc(lua_State *L)   {       int n = lua_gettop(L);       double sum = 0;       int i;          /* 循环求参数之和 */       for (i = 1; i <= n; i++)           sum += lua_tonumber(L, i);          lua_pushnumber(L, sum / n);     //压入平均值       lua_pushnumber(L, sum);         //压入和          return 2;                       //返回两个结果   }      static int sayHelloFunc(lua_State* L)   {       printf("hello world!");       return 0;   }      static const struct luaL_Reg mylib[] =    {       {"average", averageFunc},       {"sayHello", sayHelloFunc},       {NulL, NulL}       //数组中最后一对必须是{NulL, NulL}，用来表示结束       };      int luaopen_mLualib(lua_State *L)   {       luaL_register(L, "ss", mylib);       return 1;       // 把mylib表压入了栈中，所以就需要返回1   }  

#include <stdio.h>#include "mLualib.h"static int averageFunc(lua_State *L){	int n = lua_gettop(L);	double sum = 0;	int i;	/* 循环求参数之和 */	for (i = 1; i <= n; i++)		sum += lua_tonumber(L,i);	lua_pushnumber(L,sum / n);		//压入平均值	lua_pushnumber(L,sum);			//压入和	return 2;                       //返回两个结果}static int sayHelloFunc(lua_State* L){	printf("Hello World!");	return 0;}static const struct luaL_Reg mylib[] = {	{"average",averageFunc},{"sayHello",sayHelloFunc},{NulL,NulL}       //数组中最后一对必须是{NulL,NulL}，用来表示结束    };int luaopen_mLualib(lua_State *L){	luaL_register(L,"ss",mylib);	return 1;		// 把mylib表压入了栈中，所以就需要返回1}

不理解没关系，我们先编译它，然后新建一个lua文件，在lua中我们这样子来调用：（调用之前记得把dll文件复制到lua文件目录下）

[cpp] view plain copy print ? require "mLualib"   local ave,sum = ss.average(1,3,4,5)//参数对应堆栈中的数据   print(ave,sum)  -- 3 15   ss.sayHello()   -- hello world!  

require "mLualib"local ave,sum = ss.average(1,5)//参数对应堆栈中的数据print(ave,sum)  -- 3 15ss.sayHello()   -- Hello World!

成功调用了有木有？我们看到了输出信息。（木有成功你留言，我教你！）

至此都发生了什么呢？梳理一下：

1.我们编写了averageFunc求平均值和sayHelloFunc函数，
2.然后把函数封装mylib数组里面，类型必须是luaL_Reg
3.由luaopen_mLualib函数导出并在lua中注册这两个函数。

那么为什么要这样子写呢？实际上当我们在lua中：

[cpp] view plain copy print ? require "mLualib"  

require "mLualib"

这样子写的时候，lua会这么干：

[cpp] view plain copy print ? local path = "mLualib.dll"     local f = package.loadlib(path,"luaopen_mLualib")   -- 返回luaopen_mLualib函数   f()                                                 -- 执行  

local path = "mLualib.dll"  local f = package.loadlib(path,"luaopen_mLualib")   -- 返回luaopen_mLualib函数f()                                                 -- 执行

所以当我们在编写一个这样的模块的时候，编写luaopen_xxx导出函数的时候，xxx最好是和项目名一样（因为项目名和dll一样）。

需要注意的是：函数参数里的lua_State是私有的，每一个函数都有自己的栈。当一个c/c++函数把返回值压入Lua栈以后，该栈会自动被清空。

五.总结 

这篇文章花了好几天才整理的，最后总结一下就是：

lua和c++是通过一个虚拟栈来交互的。

c++调用lua实际上是：由c++先把数据放入栈中，由lua去栈中取数据，然后返回数据对应的值到栈顶，再由栈顶返回c++。

lua调c++也一样：先编写自己的c模块，然后注册函数到lua解释器中，然后由lua去调用这个模块的函数。

转载请注明出处：http://www.voidcn.com/article/p-gfrnyvpb-rq.html 总结

以上是内存溢出为你收集整理的Lua和C++交互总结（很详细）全部内容，希望文章能够帮你解决Lua和C++交互总结（很详细）所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。