C/C++与lua互调函数的方法
1，在lua脚本中调用C/C++代码中的函数
在C++中定义函数时必须以lua_State为参数, 以int为返回值才能被Lua所调用。
/*
typedef int (*lua_CFunction) (lua_State*L);
C 函数的类型。
为了正确的和 Lua 通讯，C 函数必须使用下列定义了参数以及返回值传递方法的协议： C 函数通过 Lua 中的堆栈来接受参数，参数以正序入栈（第一个参数首先入栈）。因此，当函数开始的时候， lua_gettop(L) 可以返回函数收到的参数个数。第一个参数（如果有的话）在索引 1 的地方，而最后一个参数在索引 lua_gettop(L) 处。当需要向 Lua 返回值的时候，C 函数只需要把它们以正序压到堆栈上（第一个返回值最先压入），然后返回这些返回值的个数。在这些返回值之下的，堆栈上的东西都会被 Lua 丢掉。和 Lua 函数一样，从 Lua 中调用 C 函数也可以有很多返回值。
*/
下面这个例子中的函数将接收若干数字参数，并返回它们的平均数与和：
#include
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include
#include
#include
#ifdef __cplusplus
}
#endif /* __cplusplus */
int c_average(lua_State* L)
{
int n = lua_gettop(L); /* 返回栈顶元素的索引。因为索引是从1开始编号的（1表示栈底，-1表示栈顶），所以这个结果等于堆栈上的元素个数（返回0表示堆栈为空）。这里栈中元素的个数就是传入的参数个数 */
double sum = 0;
int i;
for (i = 1; i <= n; i++)
{
if (!lua_isnumber(L, i))
{
lua_pushstring(L, "Incorrect argument to 'average'"); // 将错误信息压入栈中
lua_error(L); // 抛出栈顶的错误
/*
int lua_error (lua_State *L);
产生一个 Lua 错误。错误信息（实际上可以是任何类型的 Lua 值）必须被置入栈顶。这个函数会做一次长跳转，它不会再返回。
*/
}
sum += lua_tonumber(L, i); // lua_tonumber 将栈中指定index的值转换成数值类型的值，注意并不会从栈中弹出这个值
}
double avg = sum / n;
lua_pushnumber(L, avg); // 将avg压入栈中，第1个返回值是avg
lua_pushnumber(L, sum); // 将sum压入栈中，第2个返回值是sum
return 2; /* return the number of results，该函数有2个返回值，即上面入栈的avg和sum */
}
int main(int argc, char* argv[])
{
lua_State* L = luaL_newstate(); // 创建一个新的独立的状态机
/* register our function，告诉lua脚本其中调用的average函数（lua中的变量名）对应的是一个叫c_average的c语言函数 */
lua_register(L, "average", c_average);
/*
void lua_register (lua_State *L,
const char *name,
lua_CFunction f);
把 C 函数 f 设到全局变量 name 中。它通过一个宏定义：
#define lua_register(L,n,f) \
(lua_pushcfunction(L, f), lua_setglobal(L, n))
*/
/* run the script */
luaL_dofile(L, "e1.lua"); // 加载脚本，脚本中的可执行语句将会得到执行
/* Loads a file as a Lua chunk and then 以保护模式调用一个函数，等价于(luaL_loadfile(L,filename) || lua_pcall(L, 0, LUA_MULTRET, 0)) */
lua_getglobal(L, "avg"); // 将全局变量avg的值入栈，等价于lua_getfield(L,LUA_GLOBALSINDEX, "name")
printf("avg is: %d\n", lua_tointeger(L, -1)); // 读栈顶的int值，注意不会从栈中弹出这个元素
lua_pop(L, 1); // 弹出栈顶的一个元素
lua_getglobal(L, "sum"); // 将全局变量sum的值入栈
printf("sum is: %d\n", lua_tointeger(L, -1));
lua_pop(L, 1); // 弹出栈顶的一个元素
/* cleanup Lua */
lua_close(L);
return 0;
}
/*
-- e1.lua
avg, sum = average(10, 20, 30, 40, 50)
print("The average is ", avg)
print("The sum is ", sum)
*/
/*
输出：
The average is 30
The sum is 150
avg is: 30
sum is: 150
*/
2，在C/C++代码中调用lua脚本中的函数
在C/C++代码中通过栈将参数传递给lua脚本中的函数，参数按照正序入栈，返回值由lua按正序压入栈中供C/C++访问。（函数调用成功后函数名和参数都出栈，返回值入栈）
示例：
#include
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include
#include
#include
#ifdef __cplusplus
}
#endif /* __cplusplus */
lua_State* L = NULL;
int luaAdd(int x, int y)
{
int sum;
/* the function name，lua脚本中的函数名 */
lua_getglobal(L, "add"); // lua函数名入栈
int savedTop = lua_gettop(L); // 保存栈中的元素个数，后面要还原
/* the first argument */
lua_pushnumber(L, x); // 参数x入栈
/* the second argument */
lua_pushnumber(L, y); // 参数y入栈
// 此时栈中有3个值，栈顶是参数y，栈底是函数名add
/* call the function with 2 arguments, return 1 result */
lua_call(L, 2, 1);
/*
void lua_call (lua_State *L, int nargs, int nresults);
调用一个函数。
要调用一个函数请遵循以下协议：首先，要调用的函数应该被压入堆栈；接着，把需要传递给这个函数的参数按正序压栈；这是指第一个参数首先压栈。最后调用一下 lua_call； nargs 是你压入堆栈的参数个数。当函数调用完毕后，所有的参数以及函数本身都会出栈。而函数的返回值这时则被压入堆栈。返回值的个数将被调整为 nresults 个，除非 nresults 被设置成 LUA_MULTRET。在这种情况下，所有的返回值都被压入堆栈中。 Lua 会保证返回值都放入栈空间中。函数返回值将按正序压栈（第一个返回值首先压栈），因此在调用结束后，最后一个返回值将被放在栈顶。
lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
以保护模式调用一个函数。
nargs 和 nresults 的含义与 lua_call 中的相同。如果在调用过程中没有发生错误， lua_pcall 的行为和 lua_call 完全一致。但是，如果有错误发生的话， lua_pcall 会捕获它，然后把单一的值（错误信息）压入堆栈，然后返回错误码。同 lua_call 一样， lua_pcall 总是把函数本身和它的参数从栈上移除。
如果 errfunc 是 0 ，返回在栈顶的错误信息就和原始错误信息完全一致。否则，errfunc 就被当成是错误处理函数在栈上的索引。（在当前的实现里，这个索引不能是伪索引。）在发生运行时错误时，这个函数会被调用而参数就是错误信息。错误处理函数的返回值将被 lua_pcall 作为出错信息返回在堆栈上。
典型的用法中，错误处理函数被用来在出错信息上加上更多的调试信息，比如栈跟踪信息 (stack traceback) 。这些信息在 lua_pcall 返回后，因为栈已经展开 (unwound) ，所以收集不到了。
lua_pcall 函数在调用成功时返回 0 ，否则返回以下（定义在 lua.h 中的）错误代码中的一个：
LUA_ERRRUN: 运行时错误。
LUA_ERRMEM: 内存分配错误。对于这种错，Lua 调用不了错误处理函数。
LUA_ERRERR: 在运行错误处理函数时发生的错误。
*/
// 因为add只有一个返回值，所以此时栈中只有1个值（如果有多个返回值，也是按正序入栈）
/* get the result */
sum = (int) lua_tonumber(L, -1); // -1是栈顶
lua_pop(L, 1); // 返回值出栈
/* 取出脚本中的变量z的值 */
lua_getglobal(L, "z"); // 变量z的值入栈
int z = (int) lua_tonumber(L, -1);
printf("z = %d\n", z);
lua_pop(L, 1); // 变量z出栈
lua_pushnumber(L, 4); // 4入栈
lua_setglobal(L, "r");
/*
void lua_setglobal (lua_State *L, const char *name);
从堆栈上弹出一个值，并将其设到全局变量 name 中。它由一个宏定义出来：
#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, s)
*/
lua_getglobal(L, "r"); // 变量r的值入栈
int r = (int)lua_tonumber(L, -1);
printf("r = %d\n", r);
lua_pop(L, 1); // 变量r出栈
lua_settop(L, savedTop); // 函数退出之前恢复原来的栈
return sum;
}
int main(int argc, char* argv[])
{
L= luaL_newstate(); // 创建lua运行环境
/* load the script，加载脚本，为后面读取其中的变量做准备 */
luaL_dofile(L, "e2.lua");
/* call the add function */
int sum = luaAdd(10, 15);
/* print the result */
printf("The sum is %d\n", sum);
/* cleanup Lua */
lua_close(L);
return 0;
}
/*
-- e2.lua
-- add two numbers
function add(x, y)
return x + y
end
z = 6
*/
/*
输出：
z = 6
r = 4
The sum is 25
*/
3，综合例子
#include
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#include
#include
#include
#ifdef __cplusplus
}
#endif /* __cplusplus */
#define err_exit(num,fmt,args...) \
do{printf("[%s:%d]"fmt"\n",__FILE__,__LINE__,##args);exit(num);}while(0)
#define err_return(num,fmt,args...) \
do{printf("[%s:%d]"fmt"\n",__FILE__,__LINE__,##args);return(num);}while(0)
// lua中调用的c函数定义，实现加法
int c_sum(lua_State* L)
{
int a = lua_tointeger(L, 1);
int b = lua_tointeger(L, 2);
lua_pushinteger(L, a + b);
return 1;
}
int main(int argc, char* argv[])
{
lua_State* L = luaL_newstate(); //创建lua运行环境
if (L == NULL)
err_return(-1, "luaL_newstat() failed");
int ret = 0;
ret = luaL_loadfile(L, "e3.lua"); // Loads a file as a Luachunk. 底层调用lua_load，功能是：加载一个 Lua chunk 。如果没有错误， lua_load 把一个编译好的 chunk 作为一个 Lua 函数压入堆栈。否则，压入出错信息。
if (ret != 0)
err_return(-1, "luaL_loadfile failed");
ret = lua_pcall(L, 0, 0, 0); // 以保护模式调用一个函数。 即刚刚加载的文件
if (ret != 0)
err_return(-1, "lua_pcall failed: %s", lua_tostring(L, -1));
lua_getglobal(L, "width"); // 将全局变量width的值入栈
lua_getglobal(L, "height");// 将全局变量height的值入栈
printf("height: %ld, width: %ld\n", (long) lua_tointeger(L,-1), (long) lua_tointeger(L, -2));
lua_pop(L, 1); // 从栈中弹出一个值，从栈顶开始
int a = 11;
int b = 12;
lua_getglobal(L, "mySum1"); // 将全局变量mySum1入栈，注意这里的mySum1是一个函数
lua_pushinteger(L, a); // 第1个整型参数入栈，从左往右的顺序
lua_pushinteger(L, b); // 第2个整型参数入栈，从左往右的顺序
ret = lua_pcall(L, 2, 1, 0); // 调用函数，2个参数，1个返回值。调用成功后，函数和参数均出战，返回值入栈。如果有多个返回值，则第一个返回值先入栈
if (ret != 0)
err_return(-1, "lua_pcall failed: %s", lua_tostring(L, -1));// 调用函数失败后栈顶存放失败原因字符串
printf("sum: %d + %d = %ld\n", a, b, (long) lua_tointeger(L,-1)); // sum只有一个返回值，调用成功后栈顶存放函数的返回值
lua_pop(L, 1);
const char str1[] = "hello";
const char str2[] = "world";
lua_getglobal(L, "myStrcat"); // 调用lua中的函数myStrcat
lua_pushstring(L, str1);
lua_pushstring(L, str2);
ret = lua_pcall(L, 2, 1, 0);
if (ret != 0)
err_return(-1, "lua_pcall failed: %s", lua_tostring(L, -1));
printf("mystrcat: %s %s = %s\n", str1, str2, lua_tostring(L,-1));
lua_pop(L, 1);
lua_pushcfunction(L, c_sum); // 将一个 C 函数压入堆栈
lua_setglobal(L, "mySum2");
/*
void lua_setglobal (lua_State *L, const char *name);
从堆栈上弹出一个值，并将其设到全局变量 name 中。它由一个宏定义出来：
#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, s)
*/
// 以上两句可以用lua_register(L, "mySum2", c_sum);来代替
/* register our function，告诉lua脚本其中调用的average函数（也是一个变量名）其实对应的是一个叫c_averaged的c代码函数 */
// 调用lua中的mySum2函数，该函数调用c_sum函数实现加法
lua_getglobal(L, "mySum2");
lua_pushinteger(L, a);
lua_pushinteger(L, b);
ret = lua_pcall(L, 2, 1, 0);
if (ret != 0)
err_return(-1, "lua_pcall failed: %s", lua_tostring(L, -1));
printf("mysum: %d + %d = %ld\n", a, b, (long) lua_tointeger(L,-1));
lua_pop(L, 1);
lua_close(L); // 释放lua运行环境
return 0;
}
/*
-- e3.lua
-- 变量定义
width = 1
height = 2
-- lua函数定义，实现加法
function mySum1(a, b)
return a + b
end
-- lua函数定义，实现字符串相加
function myStrcat(a, b)
return a.. "_" .. b
end
-- lua函数定义，通过调用c代码中的csum函数实现加法
function mysum(a, b)
return csum(a, b)
end
*/
/*
输出：
height: 2, width: 1
sum: 11 + 12 = 23
mystrcat: hello world = hello_world
mysum: 11 + 12 = 23
*/