Lua和C++交互詳細總結

轉自：http://cn.cocos2d-x.org/tutorial/show?id=1474

一、Lua堆棧

要理解Lua和C++交互，首先要理解Lua堆棧。

簡單來說，Lua和C/C++語言通信的主要方法是一個無處不在的虛擬棧。棧的特點是先進后出。

在Lua中，Lua堆棧就是一個struct，堆棧索引的方式可是是正數也可以是負數，區別是：正數索引1永遠表示棧底，負數索引-1永遠表示棧頂。如圖：

 lua的棧類似於以下的定義, 它是在創建lua_State的時候創建的:

             TValue stack[max_stack_len]  // 欲知內情可以查 lstate.c 的stack_init函數

    存入棧的數據類型包括數值, 字符串, 指針, talbe, 閉包等, 下面是一個棧的例子:

          

   執行下面的代碼就可以讓你的lua棧上呈現圖中的情況

    lua_pushcclosure(L, func, 0) // 創建並壓入一個閉包

    lua_createtable(L, 0, 0)        // 新建並壓入一個表

    lua_pushnumber(L, 343)      // 壓入一個數字

    lua_pushstring(L, “mystr”)   // 壓入一個字符串

 

    這里要說明的是, 你壓入的類型有數值, 字符串, 表和閉包[在c中看來是不同類型的值], 但是最后都是統一用TValue這種數據結構來保存的:), 下面用圖簡單的說明一下這種數據結構:

    

 

    TValue結構對應於lua中的所有數據類型, 是一個{值, 類型} 結構, 這就lua中動態類型的實現, 它把值和類型綁在一起, 用tt記錄value的類型, value是一個聯合結構, 由Value定義, 可以看到這個聯合有四個域, 先說明簡單的

        p -- 可以存一個指針, 實際上是lua中的light userdata結構

        n -- 所有的數值存在這里, 不過是int , 還是float

        b -- Boolean值存在這里, 注意, lua_pushinteger不是存在這里, 而是存在n中, b只存布爾

        gc -- 其他諸如table, thread, closure, string需要內存管理垃圾回收的類型都存在這里

        gc是一個指針, 它可以指向的類型由聯合體GCObject定義, 從圖中可以看出, 有string, userdata, closure, table, proto, upvalue, thread

    從下面的圖可以的得出如下結論:

        1. lua中, number, boolean, nil, light userdata四種類型的值是直接存在棧上元素里的, 和垃圾回收無關.

        2. lua中, string, table, closure, userdata, thread存在棧上元素里的只是指針, 他們都會在生命周期結束后被垃圾回收.

 

二、堆棧的操作

因為Lua與C/C++是通過棧來通信，Lua提供了C API對棧進行操作。

我們先來看一個最簡單的例子：

#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返回一個指向堆棧的指針，其它看注釋應該能懂了吧。

 

其他一些棧操作：

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位置的值

ua_settop將棧頂設置為一個指定的位置，即修改棧中元素的數量。如果值比原棧頂高，則高的部分nil補足，如果值比原棧低，則原棧高出的部分舍棄。所以可以用lua_settop(0)來清空棧。

 

三、C++調用Lua

我們經常可以使用Lua文件來作配置文件。類似ini，xml等文件配置信息。現在我們來使用C++來讀取Lua文件中的變量，table，函數。

 

 lua和c通信時有這樣的約定: 所有的lua中的值由lua來管理, c++中產生的值lua不知道, 類似表達了這樣一種意思: "如果你(c/c++)想要什么, 你告訴我(lua), 我來產生, 然后放到棧上, 你只能通過api來操作這個值, 我只管我的世界", 這個很重要, 因為:

         "如果你想要什么, 你告訴我, 我來產生"就可以保證, 凡是lua中的變量, lua要負責這些變量的生命周期和垃圾回收, 所以, 必須由lua來創建這些值(在創建時就加入了生命周期管理要用到的簿記信息)

         "然后放到棧上, 你只能通過api來操作這個值", lua api給c提供了一套完備的操作界面, 這個就相當於約定的通信協議, 如果lua客戶使用這個操作界面, 那么lua本身不會出現任何"意料之外"的錯誤.

         "我只管我的世界"這句話體現了lua和c/c++作為兩個不同系統的分界, c/c++中的值, lua是不知道的, lua只負責它的世界

 

現在有這樣一個hello.lua 文件：

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

我們寫一個test.cpp來讀取它：

#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的值：

// 將需要設置的值設置到棧中  
lua_pushstring(L, "我是一個大帥鍋～");  
// 將這個值設置到table中（此時tbl在棧的位置為2）  
lua_setfield(L, 2, "name");

我們還可以新建一個table：

// 創建一個新的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，設置一個表的值，肯定要先將值出棧，保存，再去找表的位置。

 

再不理解可看如下例子：

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 value 和 c value的對應關系

	c	lua
nil	無	{value=0, tt = t_nil}
boolean	int  非0, 0	{value=非0/0， tt = t_boolean}
number	int/float等   1.5	{value=1.5, tt = t_number}
lightuserdata	void*, int*, 各種*  point	{value=point, tt = t_lightuserdata}
string	char  str[]	{value=gco, tt = t_string}   gco=TString obj
table	無	{value=gco, tt = t_table}  gco=Table obj
userdata	無	{value=gco, tt = t_udata} gco=Udata obj
closure	無	{value=gco, tt = t_function} gco=Closure obj

 

可以看出來, lua中提供的一些類型和c中是對應的, 也提供一些c中沒有的類型. 其中有一些葯特別的說明一下:

        nil值, c中沒有對應, 但是可以通過lua_pushnil向lua中壓入一個nil值

        注意: lua_push*族函數都有"創建一個類型的值並壓入"的語義, 因為lua中所有的變量都是lua中創建並保存的, 對於那些和c中有對應關系的lua類型, lua會通過api傳來的附加參數, 創建出對應類型的lua變量放在棧頂, 對於c中沒有對應類型的lua類型, lua直接創建出對應變量放在棧頂.

       例如:    lua_pushstring(L, “string”) lua根據"string"創建一個 TString obj, 綁定到新分配的棧頂元素上

                  lua_pushcclosure(L,func, 0) lua根據func創建一個 Closure obj, 綁定到新分配的棧頂元素上

                  lua_pushnumber(L,5) lua直接修改新分配的棧頂元素, 將5賦值到對應的域

                  lua_createtable(L,0, 0)lua創建一個Tabke obj, 綁定到新分配的棧頂元素上

 

       總之, 這是一個 c value –> lua value的流向, 不管是想把一個簡單的5放入lua的世界, 還是創建一個table, 都會導致

                  1. 棧頂新分配元素    2. 綁定或賦值

                還是為了重復一句話, 一個c value入棧就是進入了lua的世界, lua會生成一個對應的結構並管理起來, 從此就不再依賴這個c value

        lua value –> c value時, 是通過 lua_to* 族api實現, 很簡單, 取出對應的c中的域的值就行了, 只能轉化那些c中有對應值的lua value, 比如table就不能to c value, 所以api中夜沒有提供 lua_totable這樣的接口.

 

四、Lua調用C++

我們分三個方法實現它。

 

方法一：直接將模塊寫入Lua源碼中

在Lua中調用C/C++，我們可以將函數寫lua.c中，然后重新編譯Lua文件。

編譯好后是這樣子的：（如圖）

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

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

換句話說，所有的函數必須接收一個lua_State作為參數，同時返回一個整數值。因為這個函數使用Lua棧作為參數，所以它可以從棧里面讀取任意數量和任意類型的參數。而這個函數的返回值則表示函數返回時有多少返回值被壓入Lua棧。（因為Lua的函數是可以返回多個值的）

 

然后我們在lua.c中加入如下函數：

// This is my function  
static int getTwoVar(lua_State *L)  
{  
    // 向函數棧中壓入2個值  
    lua_pushnumber(L, 10);  
    lua_pushstring(L,"hello");  
   
    return 2;  
}  
 
在pmain函數中，luaL_openlibs函數后加入以下代碼：
//注冊函數  
lua_pushcfunction(L, getTwoVar); //將函數放入棧中  
lua_setglobal(L, "getTwoVar");   //設置lua全局變量getTwoVar

通過查找lua.h

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

我們發現之前的注冊函數可以這樣子寫：

lua_register(L,"getTwoVar",getTwoVar);

運行，結果如圖：

當然，一般我們不建議去修改別人的代碼，更傾向於自己編寫獨立的C/C++模塊，供Lua調用，下面來講講如何實現。

 

方法二：使用靜態依賴的方式

1. 新建一個空的win32控制台工程，記得在vc++目錄中，把lua中的頭文件和lib文件的目錄包含進來，然后->鏈接器->附加依賴項->將lua51.lib和lua5.1.lib也包含進來。

2. 在目錄下新建一個avg.lua如下：

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

3.新建test.cpp如下：

#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。）

#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文件如下：

#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文件目錄下）

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中：

require "mLualib"

這樣子寫的時候，Lua會這么干：

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去調用這個模塊的函數。

 

本文不涉及lua語法學習，如果有需要，請移步：http://book.luaer.cn/

相關閱讀：

Lua系列教程：在C/C++程序里面嵌入Lua腳本