2

次のようなコードをLuaにバインドするとします。

typedef struct bar {
  void * some_data;
} bar;
bar * bar_create(void);
void bar_do_something(bar * baz);
void bar_free(bar * baz);

これらのオブジェクトをLuaスクリプトから作成し、それらの存続期間を明示的に管理したくない。できれば、スクリプトで記述してください

require "foo"
local baz = foo:bar()
baz:do_something()
baz = nil

問題：それが期待どおりに機能するためには、bar_createとbar_freeがbarのコンストラクタ/デストラクタであることをtolua++に伝える必要があります。それ、どうやったら出来るの？クラスの場合、tolua++は自動的にctor/ dtorを使用すると主張しますが、構造体の場合はどうでしょうか。

私が思いつくことができる最も良いことは、foo.pkgのこの定義です：

module foo {
  struct bar {
    static tolua_outside bar_create @ create();
    tolua_outside bar_do_something @ do_something();
    tolua_outside bar_free @ free();
  };
}

つまり、create（）とfree（）を明示的に呼び出す必要があります。

4

1 に答える 1

1

関数は、bartolua ++を使用してLuaにインポートし、ラップして、ガベージコレクションを含むオブジェクトスタイルのインターフェイスを生成できます。

引数の受け渡しを示すために、barインターフェイスを次のように変更しました

bar * bar_create(int x);
int bar_do_something(bar * baz, int y);
void bar_free(bar * baz);

関数が呼び出されたときに、などxを出力するテスト実装を作成しました。y

Lua関数はbar_create()userdata値を返します。__gcLuaは、データのメタテーブルに格納されているメソッドを呼び出すことにより、そのようなユーザーデータの割り当てを解除します。userdata値とデストラクタを指定gcすると、__gcメソッドは上書きされ、最初gcに呼び出してから元のgcメソッドを呼び出します。

function wrap_garbage_collector(userdata, gc)
    local mt = getmetatable(userdata)
    local old_gc = mt.__gc
    function mt.__gc (data)
        gc(data)
        old_gc(data)
    end
end

同じタイプのユーザーデータは同じメタテーブルを共有します。したがって、wrap_garbage_collector()関数はクラスごとに1回だけ呼び出す必要があります（tolua ++のメタテーブルが1回作成され、終了時にのみ割り当て解除されると仮定します）。

この回答の下部には、関数をインポートし、という名前のLuaモジュールにクラスを追加する完全なbar.pkgファイルがあります。モジュールはインタープリターにロードされ（たとえば、私のSO tolua ++の例を参照）、次のように使用されます。barbarfoofoo

bars = {}

for i = 1, 3 do
    bars[i] = foo.bar(i)
end

for i = 1, 3 do
    local result = bars[i]:do_something(i * i)
    print("result:", result)
end

テストの実装は、何が起こるかを出力します。

bar(1)
bar(2)
bar(3)
bar(1)::do_something(1)
result: 1
bar(2)::do_something(4)
result: 8
bar(3)::do_something(9)
result: 27
~bar(3)
~bar(2)
~bar(1)

以下のクラスの構築はbar少し複雑です。build_class()ユーティリティは、コンストラクタ、デストラクタ、およびクラスメソッドを指定してクラス（Luaテーブル）を返します。調整が必要になることは間違いありませんが、プロトタイプのデモンストレーションとして、例は問題ないはずです。

$#include "bar.hpp"

// The bar class functions.
bar * bar_create(int x);
int bar_do_something(bar * baz, int y);
void bar_free(bar * baz);

$[
    -- Wrapping of the garbage collector of a user data value.
    function wrap_garbage_collector(userdata, gc)
        local mt = getmetatable(userdata)
        local old_gc = mt.__gc
        function mt.__gc (data)
            gc(data)
            old_gc(data)
        end
    end

    -- Construction of a class.
    --
    -- Arguments:
    --
    --   cons : constructor of the user data
    --   gc : destructor of the user data
    --   methods : a table of pairs { method = method_fun }
    --
    -- Every 'method_fun' of 'methods' is passed the user data 
    -- as the first argument.
    --
    function build_class(cons, gc, methods)
        local is_wrapped = false
        function class (args)
            -- Call the constructor.
            local value = cons(args)

            -- Adjust the garbage collector of the class (once only).
            if not is_wrapped then
                wrap_garbage_collector(value, gc)
                is_wrapped = true
            end

            -- Return a table with the methods added.
            local t = {}
            for name, method in pairs(methods) do
                t[name] =
                    function (self, ...)
                        -- Pass data and arguments to the method.
                        return (method(value, ...))
                    end
            end

            return t
        end
        return class
    end

    -- The Lua module that contains our classes.
    foo = foo or {}

    -- Build and assign the classes.
    foo.bar =
        build_class(bar_create, bar_free,
                    { do_something = bar_do_something })

    -- Clear global functions that shouldn't be visible.
    bar_create = nil
    bar_free = nil
    bar_do_something = nil
$]
于 2011-02-18T01:32:37.110 に答える