轉(zhuǎn)

執(zhí)行以下 Lua 代碼即結(jié)果:

7.3 調(diào)用Lua函數(shù)

為了調(diào)用一個(gè)Lua函數(shù), 你可以或者用 call_function() 或者用 一個(gè)對(duì)象(object).

call_function()函數(shù)有兩個(gè)重載版本.一個(gè)是根據(jù)函數(shù)的名字來調(diào)用函數(shù),
另一個(gè)是調(diào)用一個(gè)可以作為函數(shù)調(diào)用的Lua值.

使用函數(shù)名來調(diào)用的版本只能調(diào)用Lua全局函數(shù). "..."代表傳遞給Lua函數(shù)的
可變個(gè)數(shù)的參數(shù). 這使得你可以指定調(diào)用的策略.你可以通過 operator[] 來實(shí)現(xiàn)
這個(gè)功鞥.你可以同過方括號(hào)來指定策略,例如:

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

如果你想給一個(gè)函數(shù)調(diào)用指定自己的錯(cuò)誤捕獲處理函數(shù)(error handler),可以參閱
pcall errorfunc 章節(jié)的 set_pcall_callback .

7.4 使用Lua協(xié)程

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

和:

第一次開始一個(gè)協(xié)程的時(shí)候,你必須給它一個(gè)入口函數(shù). 當(dāng)一個(gè)協(xié)程返回(yield)的時(shí)候,
resume_fucntion()調(diào)用的返回值是 lua_yield()的第一個(gè)傳入?yún)?shù).當(dāng)你想要繼續(xù)一個(gè)
協(xié)程的時(shí)候,你只需要調(diào)用 resume() 在你的 lua_State() 上,因?yàn)樗呀?jīng)在執(zhí)行一個(gè)函數(shù)
(即先前出入的入口函數(shù)),所以你不需要再次傳入函數(shù).resume()的傳入?yún)?shù)將作為Lua側(cè)的
yield()調(diào)用的返回值.

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

接受 object 參數(shù)的resume_function()的重載版本要求對(duì)象必須是一個(gè)協(xié)程對(duì)象.(thread)

8 綁定類到Lua

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

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

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

這將注冊(cè) testclass 類以及接受一個(gè)string參數(shù)的構(gòu)造器以及一個(gè)成員叫print_string()的函數(shù).

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

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

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

8.1 重載成員函數(shù)

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

例如:

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

8.2 屬性

很容易注冊(cè)類的全局?jǐn)?shù)據(jù)成員.考慮如下的類:

這個(gè)類可以這樣注冊(cè):

這使得成員變量 A::a 獲得了讀寫訪問權(quán). 還可以注冊(cè)一個(gè)只讀的屬性:

當(dāng)綁定成員是一個(gè)非原始數(shù)據(jù)類型的時(shí)候,自動(dòng)生成的 getter 函數(shù)將會(huì)返回一個(gè)它引用.
這就允許你可以鏈?zhǔn)绞褂?. 操作符.例如,當(dāng)有一個(gè)結(jié)構(gòu)體包含另外一個(gè)結(jié)構(gòu)體的時(shí)候.如下:

當(dāng)綁定B到Lua的時(shí)候,下面的表達(dá)式應(yīng)該可以工作:

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

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

可以這樣注冊(cè)成一個(gè)公共數(shù)據(jù)成員:

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

8.3 枚舉

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

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

8.4 操作符

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

可以這樣注冊(cè):

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

支持如下操作符:

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

Lua不支持操作符包括: !=,>和<=.這是為什么你只能注冊(cè)上面那些操作符. 當(dāng)你調(diào)用這些操作符的時(shí)候,
Lua會(huì)把調(diào)用轉(zhuǎn)換到支持的操作符上.(譯注:例如:==和!=有邏輯非得關(guān)系)

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

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

注冊(cè)一個(gè)應(yīng)用程序操作符(函數(shù)調(diào)用):

這里有個(gè)特殊的操作符.在Lua里,它叫做 __tostring,它不是一個(gè)真正的操作符.它是被用來轉(zhuǎn)換一個(gè)對(duì)象到
string的標(biāo)準(zhǔn)Lua方法.如果你注冊(cè)之,可以通過Lua的標(biāo)準(zhǔn)函數(shù) tostring() 來轉(zhuǎn)換你的對(duì)象到一個(gè)string.

為了在C++里實(shí)現(xiàn)這個(gè)操作符,你需要為 std::ostream 提供 operator<< .像這樣:

8.5 嵌套作用域和靜態(tài)函數(shù)

可以添加嵌套的作用域到一個(gè)類.當(dāng)你需要包裝一個(gè)嵌套類或者一個(gè)靜態(tài)函數(shù)的時(shí)候就會(huì)很有用.

在上面的例子里, f 將表現(xiàn)的像一個(gè)類 foo 的靜態(tài)函數(shù),而 類 nested 將表現(xiàn)的像類 foo 的嵌套類.

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


8.6 繼承類

如果你想要注冊(cè)一個(gè)繼承自其它類的類到Lua, 你可以指定一個(gè)模板參數(shù) bases<> 給 class_ 的構(gòu)造器.
如下的繼承關(guān)系:

可以這樣注冊(cè):

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

注意,你可以省去 bases<> 當(dāng)你用的是單繼承的時(shí)候.

8.7 智能指針

當(dāng)你注冊(cè)一個(gè)類的時(shí)候,你可以告訴 LuaBind 所有的該類的實(shí)例應(yīng)該被某種智能指針持有.(例如: boost::shared_ptr)
你可通過把一個(gè) 持有器類型模板參數(shù) 給 class_ 類的構(gòu)造器來實(shí)現(xiàn)該功能.例如:

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

第二個(gè)函數(shù)只在編譯時(shí)用于映射 boost::shared_ptr到其常量版本 boost::shared_ptr.
它從來不會(huì)被調(diào)用,所以返回值是無所謂的(返回值的類型才是關(guān)鍵).

這個(gè)轉(zhuǎn)換將這樣工作(假定 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>

當(dāng)使用持有器類型的時(shí)候,知道指針是不是合法(例如:非空)是很有用的.例如,當(dāng)使用 std::auto_ptr 的時(shí)候,
持有器通過一個(gè)參數(shù)傳遞給函數(shù)的時(shí)候?qū)?huì)變得無效. 為了這個(gè)目的,所有的對(duì)象實(shí)例都有一個(gè)成員叫: __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 概念.大部分標(biāo)準(zhǔn)迭代器都有如下的成員和構(gòu)造器:

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

    object key() const;

    standard iterator members
};

接受一個(gè) luabind::object 的構(gòu)造器實(shí)際上是一個(gè)用于操作 object 的模板.通過傳入一個(gè) object 給構(gòu)造器來構(gòu)造出

一個(gè)指向 object 里的第一個(gè)元素的迭代器.

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

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

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

一個(gè)迭代器的例子如下:

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

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


9.2 相關(guān)函數(shù)

這里介紹些用于 對(duì)象 和 表 操作的函數(shù).

這個(gè)函數(shù)將會(huì)返回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);

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

rawset 和 rawget 將會(huì)翻譯調(diào)用到 lua_rawset 和 lua_rawget. 所以他們可以繞開任何原方法而給你表里實(shí)體的
真實(shí)值.

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 函數(shù)轉(zhuǎn)型對(duì)象的值到C++值.你可以給這個(gè)從lua到C++的轉(zhuǎn)換提供一個(gè)轉(zhuǎn)換策略.如果轉(zhuǎn)型失敗,
cast_failed 異常將被拋出. 如果你已經(jīng)定義了 LUABIND_NO_ERROR_CHECKING (參閱 編譯選項(xiàng))宏,就不會(huì)
進(jìn)行任何檢查,如果轉(zhuǎn)型非法,應(yīng)用程序?qū)?huì)徹底崩潰. 不拋出異常的版本會(huì)返回一個(gè)沒有初始化的
boost::optional 對(duì)象,由此來指出轉(zhuǎn)型不能進(jìn)行.

上面的函數(shù)的簽名確實(shí)是模板化的 object 參數(shù),但是這里你應(yīng)該只傳遞 object 對(duì)象.

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

這些函數(shù)分別返回全局環(huán)境表和Lua注冊(cè)表.

這個(gè)函數(shù)創(chuàng)建一個(gè)新的 table 并以一個(gè) object 來返回它.

10 在Lua里定義類

作為一個(gè)附加功能,LuaBind還提供了一個(gè) Lua側(cè)OO系統(tǒng)來綁定C++函數(shù)和對(duì)象.

class 'lua_testclass'

function lua_testclass:__init(name)-- 譯注:這個(gè)風(fēng)格類似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)-- 譯注:注意這里 : 和 . 的區(qū)別
end

這里的 super 關(guān)鍵字用來初始化基類.用戶必須在構(gòu)造器里面第一個(gè)調(diào)用 super.

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

做為函數(shù)的第一個(gè)參數(shù).

10.1 在Lua里繼承

你還可以從Lua側(cè)繼承一個(gè)C++類,并用Lua函數(shù)來覆寫虛函數(shù).為了實(shí)現(xiàn)這個(gè),我們必須為C++基類創(chuàng)建一個(gè)封裝類.

當(dāng)我們實(shí)例化一個(gè)Lua類的時(shí)候,這個(gè)封裝類將持有Lua對(duì)象.

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)
];