轉

執行以下 Lua 代碼即結果:

7.3 調用Lua函數

為了調用一個Lua函數, 你可以或者用 call_function() 或者用 一個對象(object).

call_function()函數有兩個重載版本.一個是根據函數的名字來調用函數,
另一個是調用一個可以作為函數調用的Lua值.

使用函數名來調用的版本只能調用Lua全局函數. "..."代表傳遞給Lua函數的
可變個數的參數. 這使得你可以指定調用的策略.你可以通過 operator[] 來實現
這個功鞥.你可以同過方括號來指定策略,例如:

如果你想通過引用方式傳遞參數,你必須用Boost.Ref來包裝一下.
例如:

如果你想給一個函數調用指定自己的錯誤捕獲處理函數(error handler),可以參閱
pcall errorfunc 章節的 set_pcall_callback .

7.4 使用Lua協程

為了使用Lua協程,你必須調用 lua_resume(),這就意味著你不能用先前介紹的函數
call_function()來開始一個協程.你必須用這個:

和:

第一次開始一個協程的時候,你必須給它一個入口函數. 當一個協程返回(yield)的時候,
resume_fucntion()調用的返回值是 lua_yield()的第一個傳入參數.當你想要繼續一個
協程的時候,你只需要調用 resume() 在你的 lua_State() 上,因為它已經在執行一個函數
(即先前出入的入口函數),所以你不需要再次傳入函數.resume()的傳入參數將作為Lua側的
yield()調用的返回值.

為了暫停(yielding)C++函數,(不支持在C++側和Lua側傳送數據塊),你可以使用 yield 策略.

接受 object 參數的resume_function()的重載版本要求對象必須是一個協程對象.(thread)

8 綁定類到Lua

為了注冊一個類,你可以用 class_ 類. 它的名字和C++關鍵字類似是為了比較直觀.它有一個重載
過的成員函數 def() .這個函數被用來注冊類的成員函數,操作符,構造器,枚舉和屬性.它將返回 this
指針,從而方便你直接注冊更多的成員.

讓我們開始一個簡單的例子.考慮下面的C++類:

為了注冊這個類到Lua環境,可以像下面這樣寫(假設你使用了名空間):

這將注冊 testclass 類以及接受一個string參數的構造器以及一個成員叫print_string()的函數.

還可以注冊自由函數作為成員函數.對這個自由函數的要求是,它必須接受該類的一個指針或常量指針或
引用或常量引用作為函數的第一個參數.該函數的剩下的參數將在Lua側可見,而對象指針將被賦值給第一個
參數.如果我們有如下的C++代碼:

你可以注冊 plus() 作為A的一個成員函數,如下:

plus() 現在能夠被作為A的一個接受一個int參數的成員函數來調用.如果對象指針(this指針)是const,
這個函數也將表現的像一個常量成員函數那樣(它可以通過常量對象來調用).

8.1 重載成員函數

當綁定超過一個以上的重載過的成員函數的時候,或只是綁定其中的一個的時候,你必須消除你傳遞給 def() 的
成員函數指針的歧義.為此,你可以用普通C風格的類型轉換來轉型匹配正確的重載函數. 為此,你必須知道怎么去
描述C++成員函數的類型.這里有一個簡短的教程(更多信息請查閱你的C++參考書):
成員函數指著的語法如下:

例如:

A的第一個成員函數f(int)被綁定了,而第二個沒喲被綁定.

8.2 屬性

很容易注冊類的全局數據成員.考慮如下的類:

這個類可以這樣注冊:

這使得成員變量 A::a 獲得了讀寫訪問權. 還可以注冊一個只讀的屬性:

當綁定成員是一個非原始數據類型的時候,自動生成的 getter 函數將會返回一個它引用.
這就允許你可以鏈式使用 . 操作符.例如,當有一個結構體包含另外一個結構體的時候.如下:

當綁定B到Lua的時候,下面的表達式應該可以工作:

這要求 a 屬性必須返回一個A的引用, 而不是一個拷貝. 這樣,LuaBind將會自動使用依賴策略來
確保返回值依賴于它所在的對象.所以,如果返回的引用的生命長于該對象的所有的引用(這里是b).
它將保持對象是激活的,從而避免出現懸掛指針.

你還可以注冊 getter 或者 setter 函數來使得它們看上去像一個 public 的成員.考慮下面的類:

可以這樣注冊成一個公共數據成員:

這樣 set_a() 和 get_a() 將取代簡單的數據成員操作.如果你想使之只讀,你只需要省略最后一個參數.
請注意, get 函數必須是 const 的,否則不能通過編譯.

8.3 枚舉

如果你的類包含枚舉,你可以注冊它們到Lua. 注意,它們不是類型安全的,所有的枚舉在Lua側都是整型的,
并且所有接受枚舉參數的函數都將接受任何整型.你可以像這樣注冊它們:

在Lua側,他們可以像數據成員那樣被操作,除了它們是只讀的而且屬于類本身而不是類的實例.

8.4 操作符

為了綁定操作符,你需要包含頭文件 .
注冊你的類的操作符的機制非常的簡單.你通過一個全局名字 luabind::self 來引用類自己,然后你就
可以在def()調用里面直接用操作符表達式. 類如下:

可以這樣注冊:

不管你的 + 操作符是定義在類里面還是自由函數都可以工作.
如果你的操作符是常量的(const)(或者,是一個自由函數, 接受一個類的常量的引用)你必須用
const_self 替代 self. 如下:

支持如下操作符:

這意味著,沒有"就地操作符"(in-place)(++ --). 相等操作符(==)有些敏銳;如果引用是相等的就不會
被調用. 這意味著, 相等操作符的效率非常好.

Lua不支持操作符包括: !=,>和<=.這是為什么你只能注冊上面那些操作符. 當你調用這些操作符的時候,
Lua會把調用轉換到支持的操作符上.(譯注:例如:==和!=有邏輯非得關系)

在上面的示例中,操作數的類型是 int().如果操作數的類型是復雜類型,就不是那么簡單了,你需要用 other<>
來包裝下.例如:
為了注冊如下的類,我們不想用一個string的實例來注冊這個操作符.

取而代之的是,我們用 other<> 包裝下,如下:

注冊一個應用程序操作符(函數調用):

這里有個特殊的操作符.在Lua里,它叫做 __tostring,它不是一個真正的操作符.它是被用來轉換一個對象到
string的標準Lua方法.如果你注冊之,可以通過Lua的標準函數 tostring() 來轉換你的對象到一個string.

為了在C++里實現這個操作符,你需要為 std::ostream 提供 operator<< .像這樣:

8.5 嵌套作用域和靜態函數

可以添加嵌套的作用域到一個類.當你需要包裝一個嵌套類或者一個靜態函數的時候就會很有用.

在上面的例子里, f 將表現的像一個類 foo 的靜態函數,而 類 nested 將表現的像類 foo 的嵌套類.

還可以用同樣的語法添加名空間到類里面.


8.6 繼承類

如果你想要注冊一個繼承自其它類的類到Lua, 你可以指定一個模板參數 bases<> 給 class_ 的構造器.
如下的繼承關系:

可以這樣注冊:

如果你使用了多繼承,你可以指定多于一個的基類.如果 B 還繼承了類 C , 它可以這樣注冊:

注意,你可以省去 bases<> 當你用的是單繼承的時候.

8.7 智能指針

當你注冊一個類的時候,你可以告訴 LuaBind 所有的該類的實例應該被某種智能指針持有.(例如: boost::shared_ptr)
你可通過把一個 持有器類型模板參數 給 class_ 類的構造器來實現該功能.例如:

你還必須為你的智能指針提供兩個函數.一個返回常量版本的智能指針類型(這里是: boost:shared_ptr< const A >).
另一個函數要可以從智能指針萃取流指針(raw pointer). 之所以需要第一個函數是因為,LuaBind 允許
非常量 -> 轉換在傳遞Lua值到C++的時候.之所以需要第二個函數是因為,當Lua調用一個被智能指針持有
的類的成員函數的時候,this 指針必須是一個流指針.還有一個原因是,從Lua轉換到C++的時候,需要實現
智能指針到普通指針的轉換.看上去像這樣:

第二個函數只在編譯時用于映射 boost::shared_ptr到其常量版本 boost::shared_ptr.
它從來不會被調用,所以返回值是無所謂的(返回值的類型才是關鍵).

這個轉換將這樣工作(假定 B 是A的基類):
從Lua到C++

Source	Target
holder_type	A*
holder_type	B*
holder_type	A const*
holder_type	B const*
holder_type	holder_type
holder_type	holder_type<A const>
holder_type<A const>	A const*
holder_type<A const>	B const*
holder_type<A const>	holder_type<A const

從C++到Lua

Source	Target
holder_type	holder_type
holder_type<A const>	holder_type<A const>
holder_type const&	holder_type
holder_type<A const> const&	holder_type<A const>

當使用持有器類型的時候,知道指針是不是合法(例如:非空)是很有用的.例如,當使用 std::auto_ptr 的時候,
持有器通過一個參數傳遞給函數的時候將會變得無效. 為了這個目的,所有的對象實例都有一個成員叫: __ok.

struct X {};
void f(std::auto_ptr);

module(L)
[
    class_<X, std::auto_ptr >("X")
        .def(constructor<>()),

    def("f", &f)
];

Lua 5.0  Copyright (C) 1994-2003 Tecgraf, PUC-Rio
> a = X()
> f(a)
> print a.__ok
false

module(L)
[
    class_<base, boost::shared_ptr >("base")
        .def(constructor<>()),
    class_<derived, base, boost::shared_ptr >("base")
        .def(constructor<>())
];

void register_part1(class_& x)
{
    x.def(/*...*/);
}

void register_part2(class_& x)
{
    x.def(/*...*/);
}

void register_(lua_State* L)
{
    class_ x("x");

    register_part1(x);
    register_part2(x);

    module(L) [ x ];
}

class object
{
public:
    template
    object(lua_State*, T const& value);
    object(from_stack const&);
    object(object const&);
    object();

    ~object();

    lua_State* interpreter() const;
    void push() const;
    bool is_valid() const;
    operator safe_bool_type () const;

    template
    implementation-defined operator[](Key const&);

    template
    object& operator=(T const&);
    object& operator=(object const&);

    bool operator==(object const&) const;
    bool operator<(object const&) const;
    bool operator<=(object const&) const;
    bool operator>(object const&) const;
    bool operator>=(object const&) const;
    bool operator!=(object const&) const;

    template 
    implementation-defined operator[](T const& key) const

    void swap(object&);

    implementation-defined operator()();

    template
    implementation-defined operator()(A0 const& a0);

    template
    implementation-defined operator()(A0 const& a0, A1 const& a1);

    /* ... */
};

object o;
// ...
if (o)
{
    // ...
}

...

object o;
// ...
if (o.is_valid())
{
    // ...
}

my_function_object(
    2
  , 8
  , new my_complex_structure(6)
) [ adopt(_3) ];

void my_function(object const& table)
{
    if (type(table) == LUA_TTABLE)
    {
        table["time"] = std::clock();
        table["name"] = std::rand() < 500 ? "unusual" : "usual";

        std::cout << object_cast(table[5]) << "n";
    }
}

ForwardIterator 概念.大部分標準迭代器都有如下的成員和構造器:

class iterator
{
    iterator();
    iterator(object const&);

    object key() const;

    standard iterator members
};

接受一個 luabind::object 的構造器實際上是一個用于操作 object 的模板.通過傳入一個 object 給構造器來構造出

一個指向 object 里的第一個元素的迭代器.

缺省的構造器將會初始化迭代器為一個指向最后一個元素的后面位置的迭代器.這可以用來測試是否抵達了序列的末端.

迭代器的值類型是一個支持和 luabind::object 相同的操作的代理類型.這意味著,大部分情況下你可以當它就是一個原始
的 object 實例. 它們之間的不同之處在于,任何對代理的賦值操作都會導致值被插入到表中迭代器所指的位置.

key() 成員返回迭代器用于索引表的鍵.

一個迭代器的例子如下:

for (iterator i(globals(L)["a"]), end; i != end; ++i)
{
  *i = 1;
}

end 迭代器是一個缺省的指向序列末尾的迭代器.在這個例子里,我們簡單的迭代了表 a 里面所有的實體,并將之賦值為 1.


9.2 相關函數

這里介紹些用于 對象 和 表 操作的函數.

這個函數將會返回lua類型索引.例如: . LUA_TNIL, LUA_TNUMBER 等.

template
void settable(object const& o, K const& key, T const& value);
template
object gettable(object const& o, K const& key);
template
void rawset(object const& o, K const& key, T const& value);
template
object rawget(object const& o, K const& key);

這些函數是用來索引 table 用的. settable 和 gettable 函數分別翻譯調用到 lua_settable 和 lua_gettable 函數.
這意味著,你可以在對象上使用索引操作符.

rawset 和 rawget 將會翻譯調用到 lua_rawset 和 lua_rawget. 所以他們可以繞開任何原方法而給你表里實體的
真實值.

template
T object_cast(object const&);
template
T object_cast(object const&, Policies);

template
boost::optional object_cast_nothrow(object const&);
template
boost::optional object_cast_nothrow(object const&, Policies);

object_cast 函數轉型對象的值到C++值.你可以給這個從lua到C++的轉換提供一個轉換策略.如果轉型失敗,
cast_failed 異常將被拋出. 如果你已經定義了 LUABIND_NO_ERROR_CHECKING (參閱 編譯選項)宏,就不會
進行任何檢查,如果轉型非法,應用程序將會徹底崩潰. 不拋出異常的版本會返回一個沒有初始化的
boost::optional 對象,由此來指出轉型不能進行.

上面的函數的簽名確實是模板化的 object 參數,但是這里你應該只傳遞 object 對象.

object globals(lua_State*);
object registry(lua_State*);

這些函數分別返回全局環境表和Lua注冊表.

這個函數創建一個新的 table 并以一個 object 來返回它.

10 在Lua里定義類

作為一個附加功能,LuaBind還提供了一個 Lua側OO系統來綁定C++函數和對象.

class 'lua_testclass'

function lua_testclass:__init(name)-- 譯注:這個風格類似Python的OO語法
    self.name = name
end

function lua_testclass:print()
    print(self.name)
end

a = lua_testclass('example')
a:print()

在Lua類之間可以使用繼承:

class 'derived' (lua_testclass)

function derived:__init() super('derived name')
end

function derived:print()
    print('Derived:print() -> ')
    lua_testclass.print(self)-- 譯注:注意這里 : 和 . 的區別
end

這里的 super 關鍵字用來初始化基類.用戶必須在構造器里面第一個調用 super.

正如你在這個例子里看到的,你可以調用基類的成員函數.你可以找到所有的基類成員,但是你必須把 this指針(self)

做為函數的第一個參數.

10.1 在Lua里繼承

你還可以從Lua側繼承一個C++類,并用Lua函數來覆寫虛函數.為了實現這個,我們必須為C++基類創建一個封裝類.

當我們實例化一個Lua類的時候,這個封裝類將持有Lua對象.

class base
{
public:
    base(const char* s)
    { std::cout << s << "n"; }

    virtual void f(int a) 
    { std::cout << "f(" << a << ")n"; }
};

struct base_wrapper : base, luabind::wrap_base
{
    base_wrapper(const char* s)
        : base(s) 
    {}

    virtual void f(int a) 
    { 
        call("f", a); 
    }

    static void default_f(base* ptr, int a)
    {
        return ptr->base::f(a);
    }
};

...

module(L)
[
    class_
            ("base")
        .def(constructor())
        .def("f", &base::f, &base_wrapper::default_f)
];