Lua和C++交互总结(很详细)

出处: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对栈进行操作。

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


  1. #include <iostream>  
  2. #include <string.h>  
  3. using namespace std;  
  4.   
  5. extern "C"  
  6. {  
  7.     #include "lua.h"  
  8.     #include "lauxlib.h"  
  9.     #include "lualib.h"  
  10. }  
  11. void main()  
  12. {  
  13.     //1.创建一个state  
  14.     lua_State *L = luaL_newstate();  
  15.       
  16.     //2.入栈操作  
  17.     lua_pushstring(L, "I am so cool~");   
  18.     lua_pushnumber(L,20);  
  19.   
  20.     //3.取值操作  
  21.     if( lua_isstring(L,1)){             //判断是否可以转为string  
  22.         cout<<lua_tostring(L,1)<<endl;  //转为string并返回  
  23.     }  
  24.     if( lua_isnumber(L,2)){  
  25.         cout<<lua_tonumber(L,2)<<endl;  
  26.     }  
  27.   
  28.     //4.关闭state  
  29.     lua_close(L);  
  30.     return ;  
  31. }  
#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://blog.csdn.net/shun_fzll/article/details/39078971


其他一些栈操作:


  1. int   lua_gettop (lua_State *L);            //返回栈顶索引(即栈长度)  
  2. void  lua_settop (lua_State *L, int idx);   //                
  3. void  lua_pushvalue (lua_State *L, int idx);//将idx索引上的值的副本压入栈顶  
  4. void  lua_remove (lua_State *L, int idx);   //移除idx索引上的值  
  5. void  lua_insert (lua_State *L, int idx);   //弹出栈顶元素,并插入索引idx位置  
  6. void  lua_replace (lua_State *L, int idx);  //弹出栈顶元素,并替换索引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);	//弹出栈顶元素,并插入索引idx位置
void  lua_replace (lua_State *L, int idx);	//弹出栈顶元素,并替换索引idx位置的值


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

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


三.c++调用lua


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


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


  1. str = "I am so cool"  
  2. tbl = {name = "shun", id = 20114442}  
  3. function add(a,b)  
  4.     return a + b  
  5. end  
str = "I am so cool"
tbl = {name = "shun", id = 20114442}
function add(a,b)
	return a + b
end


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


  1. #include <iostream>  
  2. #include <string.h>  
  3. using namespace std;  
  4.   
  5. extern "C"  
  6. {  
  7.     #include "lua.h"  
  8.     #include "lauxlib.h"  
  9.     #include "lualib.h"  
  10. }  
  11. void main()  
  12. {  
  13.     //1.创建Lua状态  
  14.     lua_State *L = luaL_newstate();  
  15.     if (L == NULL)  
  16.     {  
  17.         return ;  
  18.     }  
  19.   
  20.     //2.加载lua文件  
  21.     int bRet = luaL_loadfile(L,"hello.lua");  
  22.     if(bRet)  
  23.     {  
  24.         cout<<"load file error"<<endl;  
  25.         return ;  
  26.     }  
  27.   
  28.     //3.运行lua文件  
  29.     bRet = lua_pcall(L,0,0,0);  
  30.     if(bRet)  
  31.     {  
  32.         cout<<"pcall error"<<endl;  
  33.         return ;  
  34.     }  
  35.   
  36.     //4.读取变量  
  37.     lua_getglobal(L,"str");  
  38.     string str = lua_tostring(L,-1);  
  39.     cout<<"str = "<<str.c_str()<<endl;        //str = I am so cool~  
  40.   
  41.     //5.读取table  
  42.     lua_getglobal(L,"tbl");   
  43.     lua_getfield(L,-1,"name");  
  44.     str = lua_tostring(L,-1);  
  45.     cout<<"tbl:name = "<<str.c_str()<<endl; //tbl:name = shun  
  46.   
  47.     //6.读取函数  
  48.     lua_getglobal(L, "add");        // 获取函数,压入栈中  
  49.     lua_pushnumber(L, 10);          // 压入第一个参数  
  50.     lua_pushnumber(L, 20);          // 压入第二个参数  
  51.     int iRet= lua_pcall(L, 2, 1, 0);// 调用函数,调用完成以后,会将返回值压入栈中,2表示参数个数,1表示返回结果个数。  
  52.     if (iRet)                       // 调用出错  
  53.     {  
  54.         const char *pErrorMsg = lua_tostring(L, -1);  
  55.         cout << pErrorMsg << endl;  
  56.         lua_close(L);  
  57.         return ;  
  58.     }  
  59.     if (lua_isnumber(L, -1))        //取值输出  
  60.     {  
  61.         double fValue = lua_tonumber(L, -1);  
  62.         cout << "Result is " << fValue << endl;  
  63.     }  
  64.   
  65.     //至此,栈中的情况是:  
  66.     //=================== 栈顶 ===================   
  67.     //  索引  类型      值  
  68.     //   4   int:      30   
  69.     //   3   string:   shun   
  70.     //   2   table:     tbl  
  71.     //   1   string:    I am so cool~  
  72.     //=================== 栈底 ===================   
  73.   
  74.     //7.关闭state  
  75.     lua_close(L);  
  76.     return ;  
  77. }  
#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,0,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 ;
}


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


  1. // 将需要设置的值设置到栈中  
  2. lua_pushstring(L, "我是一个大帅锅~");  
  3. // 将这个值设置到table中(此时tbl在栈的位置为2)  
  4. lua_setfield(L, 2, "name");  
// 将需要设置的值设置到栈中
lua_pushstring(L, "我是一个大帅锅~");
// 将这个值设置到table中(此时tbl在栈的位置为2)
lua_setfield(L, 2, "name");


我们还可以新建一个table:


  1. // 创建一个新的table,并压入栈  
  2. lua_newtable(L);  
  3. // 往table中设置值  
  4. lua_pushstring(L, "Give me a girl friend !"); //将值压入栈  
  5. 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,设置一个表的值,肯定要先将值出栈,保存,再去找表的位置。


再不理解可看如下例子:

  1. lua_getglobal(L, "add");        // 获取函数,压入栈中  
  2. lua_pushnumber(L, 10);          // 压入第一个参数  
  3. lua_pushnumber(L, 20);          // 压入第二个参数  
  4. int iRet= lua_pcall(L, 2, 1, 0);// 将2个参数出栈,函数出栈,压入函数返回结果  
  5.   
  6. lua_pushstring(L, "我是一个大帅锅~");  //   
  7. lua_setfield(L, 2, "name");             // 会将"我是一个大帅锅~"出栈  
lua_getglobal(L, "add");		// 获取函数,压入栈中
lua_pushnumber(L, 10);			// 压入第一个参数
lua_pushnumber(L, 20);			// 压入第二个参数
int iRet= lua_pcall(L, 2, 1, 0);// 将2个参数出栈,函数出栈,压入函数返回结果

lua_pushstring(L, "我是一个大帅锅~");  // 
lua_setfield(L, 2, "name");             // 会将"我是一个大帅锅~"出栈

另外补充一下:

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


四.lua调用c++


我们分三个方法实现它。


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


在lua中调用c/c++,我们可以将函数写lua.c中,然后重新编译lua文件。
也许你用的是lua for windows集成环境,没关系,不会编译lua可以参考这篇:http://blog.csdn.net/snlscript/article/details/15533373


编译好后是这样子的:(如图)




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


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


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


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


  1. // This is my function  
  2. static int getTwoVar(lua_State *L)  
  3. {  
  4.     // 向函数栈中压入2个值  
  5.     lua_pushnumber(L, 10);  
  6.     lua_pushstring(L,"hello");  
  7.   
  8.     return 2;  
  9. }  
// This is my function
static int getTwoVar(lua_State *L)
{
    // 向函数栈中压入2个值
    lua_pushnumber(L, 10);
    lua_pushstring(L,"hello");

    return 2;
}


在pmain函数中,luaL_openlibs函数后加入以下代码:


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

通过查找lua.h


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


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


  1. 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如下:


  1. avg, sum = average(10, 20, 30, 40, 50)  
  2. print("The average is ", avg)  
  3. 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如下:


  1. #include <stdio.h>  
  2.   
  3. extern "C" {  
  4. #include "lua.h"  
  5. #include "lualib.h"  
  6. #include "lauxlib.h"  
  7. }  
  8.   
  9. /* 指向Lua解释器的指针 */  
  10. lua_State* L;  
  11. static int average(lua_State *L)  
  12. {  
  13.     /* 得到参数个数 */  
  14.     int n = lua_gettop(L);  
  15.     double sum = 0;  
  16.     int i;  
  17.   
  18.     /* 循环求参数之和 */  
  19.     for (i = 1; i <= n; i++)  
  20.     {  
  21.         /* 求和 */  
  22.         sum += lua_tonumber(L, i);  
  23.     }  
  24.     /* 压入平均值 */  
  25.     lua_pushnumber(L, sum / n);  
  26.     /* 压入和 */  
  27.     lua_pushnumber(L, sum);  
  28.     /* 返回返回值的个数 */  
  29.     return 2;  
  30. }  
  31.   
  32. int main ( int argc, char *argv[] )  
  33. {  
  34.     /* 初始化Lua */  
  35.     L = lua_open();  
  36.   
  37.     /* 载入Lua基本库 */  
  38.     luaL_openlibs(L);  
  39.     /* 注册函数 */  
  40.     lua_register(L, "average", average);  
  41.     /* 运行脚本 */  
  42.     luaL_dofile(L, "avg.lua");  
  43.     /* 清除Lua */  
  44.     lua_close(L);  
  45.   
  46.     /* 暂停 */  
  47.     printf( "Press enter to exit…" );  
  48.     getchar();  
  49.     return 0;  
  50. }  
#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://blog.csdn.net/shun_fzll/article/details/39078971。)


  1. #pragma once  
  2.   
  3. extern "C" {  
  4. #include "lua.h"  
  5. #include "lualib.h"  
  6. #include "lauxlib.h"  
  7. }  
  8.   
  9. #ifdef LUA_EXPORTS  
  10. #define LUA_API __declspec(dllexport)  
  11. #else  
  12. #define LUA_API __declspec(dllimport)  
  13. #endif  
  14.   
  15. extern "C" LUA_API int luaopen_mLualib(lua_State *L);//定义导出函数  
#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);//定义导出函数

.cpp文件如下:


  1. #include <stdio.h>  
  2. #include "mLualib.h"  
  3.   
  4. static int averageFunc(lua_State *L)  
  5. {  
  6.     int n = lua_gettop(L);  
  7.     double sum = 0;  
  8.     int i;  
  9.   
  10.     /* 循环求参数之和 */  
  11.     for (i = 1; i <= n; i++)  
  12.         sum += lua_tonumber(L, i);  
  13.   
  14.     lua_pushnumber(L, sum / n);     //压入平均值  
  15.     lua_pushnumber(L, sum);         //压入和  
  16.   
  17.     return 2;                       //返回两个结果  
  18. }  
  19.   
  20. static int sayHelloFunc(lua_State* L)  
  21. {  
  22.     printf("hello world!");  
  23.     return 0;  
  24. }  
  25.   
  26. static const struct luaL_Reg myLib[] =   
  27. {  
  28.     {"average", averageFunc},  
  29.     {"sayHello", sayHelloFunc},  
  30.     {NULL, NULL}       //数组中最后一对必须是{NULL, NULL},用来表示结束      
  31. };  
  32.   
  33. int luaopen_mLualib(lua_State *L)  
  34. {  
  35.     luaL_register(L, "ss", myLib);  
  36.     return 1;       // 把myLib表压入了栈中,所以就需要返回1  
  37. }  
#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文件目录下)


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

成功调用了有木有?我们看到了输出信息。(木有成功你留言,我教你!)

至此都发生了什么呢?梳理一下:

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

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


  1. require "mLualib"  
require "mLualib"


这样子写的时候,lua会这么干:


  1. local path = "mLualib.dll"    
  2. local f = package.loadlib(path,"luaopen_mLualib")   -- 返回luaopen_mLualib函数  
  3. 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://blog.csdn.net/shun_fzll/article/details/39120965
阅读更多
个人分类: LUA
上一篇开源游戏引擎哪家强?
下一篇luaL_dofile和luaL_loadfile的区别
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭