本节我将一步一步带领大家完成c++调用lua函数并接受lua的返回值，通过分析调用的方式来封装一个类，最终封装完成的类并不是最优的，但应该能够满足一般的项目中对lua调用的功能。不足之处欢迎大家给予指正。

1 基本概念

1.1 栈

c++调用lua是通过一个抽象的栈来实现数据的交换的。C++调用lua时，首先需要把lua函数需要的参数压入这个抽象的栈中，如果c++想要从lua中获取数据，则lua需要先把数据压入栈中，然后c++从栈中取得需要的数据。Lua是以严格的LIFO规则来操作栈的，即后进先出原则，而c++则可以操作栈上的任何一个元素。

2 常用函数

  • void lua_pushnil (lua_State *L);
往栈中压入空值
  • void lua_pushboolean (lua_State *L, int bool);
往栈中压入布尔型值
  • void lua_pushnumber (lua_State *L, double n);
往栈中压入double型数值
  • void lua_pushlstring (lua_State *L, const char *s, size_t length);
往栈中压入字符串，但是该字符串中可以包含'\0'，字符串的长度为length
  • void lua_pushstring (lua_State *L, const char *s);
往栈中压入c风格的字符串，以'\0'结尾
  • int lua_is... (lua_State *L, int index);
用来检查栈上的一个元素是否指定的类型
  • int lua_type (lua_State *L, int index);
返回栈中元素的类型
在lua.h中定义了各个元素对应的常量：LUA_TNIL、LUA_TBOOLEAN、LUA_TNUMBER、LUA_TSTRING、LUA_TTABLE、LUA_TFUNCTION、LUA_TUSERDATA以及LUA_TTHREAD
  • int lua_toboolean (lua_State *L, int index);
将元素值转换为布尔型
  • double lua_tonumber (lua_State *L, int index);
将元素值转换为数值型
  • const char * lua_tostring (lua_State *L, int index);
该函数返回一个指向lua栈内元素的指针，该指针是不允许修改的
切记这里的指针是指向栈上元素的，如果lua清空了栈内元素，则该指针就无效了。
  • int lua_gettop (lua_State *L);
返回堆栈中的元素个数，它也是栈顶元素的索引
  • void lua_settop (lua_State *L, int index);
设置栈顶为一个指定的值
如果原栈顶大于新栈顶，则顶部的值被丢弃，如果原栈顶小于新栈顶，则将多出的元素赋nil。lua_settop(L,0)清空堆栈。
你也可以用负数索引作为调用lua_settop的参数；那将会设置栈顶到指定的索引。利用这种技巧，API提供了下面这个宏，它从堆栈中弹出n个元素：
#define lua_pop(L,n) lua_settop(L, -(n)-1) 
Ø  void lua_pushvalue (lua_State *L, int index);
将指定元素的一个备份拷贝到栈顶 
Ø  void lua_replace (lua_State *L, int index);
移除指定元素，其上的其它元素依次下移
Ø  void lua_insert (lua_State *L, int index); 
将栈顶的元素移动到指定的索引处，其它元素依次上移
Ø  void lua_replace (lua_State *L, int index); 
将栈顶的值替换指定索引的元素，其它元素不变

3 一个简单的例子

该例子最终是通过c++代码调用lua脚本实现加法的操作并把返回值打印到控制台上。以下是代码:
test.cpp
复制代码 
#include <iostream>
#include "lua.hpp"
using namespace std;

int main()
{
int iRet = 0;
double iValue = 0;
    lua_State * L = luaL_newstate();// 创建lua状态
    if (NULL == L)
    {
        cout << "luaL_newstate()没有足够的内存分配\n" << endl;
return 0;
    }
    iRet = luaL_dofile(L, "test.lua");// 加载并运行lua脚本
    if (0 != iRet)
    {
        cout << "luaL_dofile() failed\n" << endl;
return 0;
    }
    lua_getglobal(L, "add"); // 把函数名压入堆栈
    
    lua_pushnumber(L, 2);
    lua_pushnumber(L, 3);
    iRet = lua_pcall(L, 2, 1, 0); // 调用函数
    if (0 != iRet)
    {
        printf("lua_pcall failed:%s\n",lua_tostring(L,-1));
return 0;
    }

if (lua_isnumber(L, -1) == 1)
    {
        iValue = lua_tonumber(L, -1);
    }
    cout << iValue << endl;

    lua_close(L);
return 0;
}
复制代码


test.lua 
function add (x,y)
return x+y
end


编译：g++ -o test test.cpp -ltolua++
运行结果：5
以下是对该例子中用到的函数的解释：
  • lua_State *luaL_newstate (void);
该函数用于创建一个新的lua状态，当内存分配错误的时候返回NULL
  • int luaL_loadfile (lua_State *L, const char *filename);
该函数加载lua文件，但不运行。
  • int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
该函数用于调用lua的函数，nargs是入参个数，nresults是出参个数，如果errfunc为0，表示把出错的信息放入堆栈中，如果不为0，则该值代表一个错误处理函数在lua堆栈中的索引。函数成功时返回0，错误时返回如下三个值：
LUA_ERRRUN：运行时错误；
LUA_ERRMEM：内存分配错误。对于这样的错误，Lua不调用错误处理函数；
LUA_ERRERR：运行错误处理函数的错误。
  • int luaL_dofile (lua_State *L, const char *filename);
加载并运行指定的文件，正确的时候返回0，错误的时候返回1。该函数在lua中被定义为一个宏：
(luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
  • void lua_getglobal (lua_State *L, const char *name);
将函数名压入到堆栈中，它被定义为如下宏：
#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, s)
  • void lua_close (lua_State *L);
该函数销毁lua状态的所有对象，如果是守护进程或web服务器，则需要在使用完后尽快释放，以避免过大。
如果想直接验证lua脚本可以按如下步骤操作：
/home/tolua/test#lua
Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio
> dofile("test.lua")
> print (add(1,4))
5

4 封装

让我们仔细研究下这个简单的例子，是不是发现了很多共同点呢？我们完全可以利用 c++的特性对其进行封装，这样我们再调用lua的时候，就可以直接调用我们封装好的类啦。
CToLua.h
复制代码 
#ifndef    CTOLUA_H_
#define  CTOLUA_H_

#include "lua.hpp"
#include <iostream>
using namespace std;

class CToLua
{
public:
    CToLua();
    ~CToLua();
bool loadLuaFile(const char* pFileName); //加载指定的Lua文件
    double callFileFn(const char* pFunctionName, const char* format, ...); //执行指定Lua文件中的函数
    lua_State* getState();
private:
int parseParameter(const char* format, va_list& arg_ptr);
    lua_State* m_pState;
};

#endif // CTOLUA_H_
复制代码

复制代码 
#include "CToLua.h"

extern "C"
{
#include "tolua++.h"
}

CToLua::CToLua()
{
    m_pState = luaL_newstate();
if (NULL == m_pState)
    {
        printf("luaL_newstate()没有足够的内存分配\n");
    }
else
    {
        luaopen_base(m_pState);
    }
}

CToLua::~CToLua()
{
if (NULL != m_pState)
    {
        lua_close(m_pState);
        m_pState = NULL;
    }
}

bool CToLua::loadLuaFile(const char* pFileName)
{
int iRet = 0;
if (NULL == m_pState)
    {
        printf("[CToLua::LoadLuaFile]m_pState is NULL.\n");
return false;
    }

    iRet = luaL_dofile(m_pState, pFileName);
if (iRet != 0)
    {
        printf("[CToLua::LoadLuaFile]luaL_dofile(%s) is error(%d)(%s).\n",
            pFileName, iRet, lua_tostring(m_pState, -1));
        lua_pop(m_pState, 1); // 及时清理堆栈
        return false;
    }

return true;
}

double CToLua::callFileFn(const char* pFunctionName, const char* format, ...)
{
int iRet = 0;
double iValue = 0;

int iTop = lua_gettop(m_pState);
    lua_pop(m_pState, iTop); // 清栈

if(NULL == m_pState)
    {
        printf("[CLuaFn::CallFileFn]m_pState is NULL.\n");
return 0;
    }

    lua_getglobal(m_pState, pFunctionName);

    va_list arg_ptr;
    va_start(arg_ptr, format);
    iRet = parseParameter(format, arg_ptr);
    va_end(arg_ptr);

    iRet = lua_pcall(m_pState, iRet, 1, 0);
if (iRet != 0)
    {
        printf("[CLuaFn::CallFileFn]call function(%s) error(%d).\n", pFunctionName, iRet);
return 0;
    }

if (lua_isnumber(m_pState, -1) == 1)
    {
        iValue = lua_tonumber(m_pState, -1);
    }

return iValue;
}

int CToLua::parseParameter(const char* format, va_list& arg_ptr)
{
int iRet = 0;
char* pFormat = (char*) format;
while (*pFormat != '\0')
    {
if ('%' == *pFormat)
        {
            ++pFormat;
switch (*pFormat)
            {
case 'f':
                lua_pushnumber(m_pState, va_arg( arg_ptr, double));
break;
case 'd':
case 'i':
                lua_pushnumber(m_pState, va_arg( arg_ptr, int));
break;
case 's':
                lua_pushstring(m_pState, va_arg( arg_ptr, char*));
break;
case 'z':
                lua_pushlightuserdata(m_pState, va_arg( arg_ptr, void*));
break;
default:
break;
            }
            ++iRet;
        }
        ++pFormat;
    }
return iRet;
}

lua_State* CToLua::getState()
{
return m_pState;
}
复制代码
main.cpp
复制代码 
#include "CToLua.h"

int main()
{
    CToLua tolua;
    tolua.loadLuaFile("C:\\c++\\lua\\test.lua");
double iValue = tolua.callFileFn("add", "%d%f", 20, 3.69); // 23.69
    cout << iValue << endl;
    iValue = tolua.callFileFn("sub", "%f%i", 23.69,20); // 3.69
    cout << iValue << endl;
return 0;
}
复制代码
test.lua
复制代码 
function add (x,y)
return x+y
end

function sub (x,y)
return x-y
end
复制代码
callFileFn方法使用类似printf，%d或%i代表整数，%f代表浮点数，%s代表字符串，%z代表自定义类型。
由于lua可以支持多返回值，所以原先的设计思想是返回一个vector，里边包含一个结构体，有两个成员，一个是string type，一个是void* pValue。但当我实现了后，发现虽然支持了多个返回值了，但是使用起来却不是那么方便。所以索性就不实现这种返回多个返回值的接口了。函数的返回值固定，只返回double类型的值，如果想要多个返回值，可以传自定义参数来实现。
在这里推荐一下linux下的eclipse c++开发环境，本次代码编写就是在该环境下进行的，使用起来还算比较舒服。搭建方式参考 http://www.cnblogs.com/osyun/archive/2011/12/05/2276412.html