원본 클래스 코드 :

class test_klass {
  object objfunc_;
public:
  void register_callback(object functor_) {
    if (functor_.is_valid() && functor_.type() == LUA_TFUNCTION)
      objfunc = functor_;
    else
    {
      object dummy;
      objfunc = dummy;
    }
  }
  void run_callback() {
    if (objfunc) objfunc();
  }
};

등록 코드 :

module(L, "test") 
[
  class_<test_klass>("test_klass")
    .def(constructor< >())
    .def("register",  &lua_Connector::register_callback)
    .def("run",       &lua_Connector::run_callback)
];

lua 코드 예제 :

a = test.test_klass()
function callback1() print("이것이 보이면 실행성공!") end
a:register(callback1)
a:run()

이것은 엔진제작시 엔진에서 객체를 스크립트에서 확장할 수 있도록 하고자 할 때 유용합니다. virtual 함수를 포함하는 C++ 클래스의 lua 이식은 상당히 귀찮으므로 이정도로도 괜찮을듯...

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

#include <string>
#include <iostream>

#include <luabind/luabind.hpp>
#include <luabind/out_value_policy.hpp>

using namespace std;
using namespace luabind;

static const luaL_reg lualibs[] = {
  {"base", luaopen_base},
  {"table", luaopen_table},
  {"io", luaopen_io},
  {"string", luaopen_string},
  {"math", luaopen_math},
  {"debug", luaopen_debug},
  {"loadlib", luaopen_loadlib},
  {NULL, NULL}
};

static void openstdlibs (lua_State *l) {
  const luaL_reg *lib = lualibs;
  for (; lib->func; lib++) {
    lib->func(l);  /* open library */
    lua_settop(l, 0);  /* discard any results */
  }
}

class baseclip {
public:
	int x, y;
	baseclip() {}
	void get(int &x_, int &y_) { x_ = x; y_ = y; }
	void set(int x_, int y_) { x = x_; y = y_; }
	const char *type() {return "clip";}
};

int main(int argc, char **argv) {
	lua_State *L = lua_open();
	openstdlibs(L);

	luabind::open(L);

	module (L)
	[
		class_<baseclip>("clip")
			.def(constructor<>())
			.def("get", &baseclip::get, pure_out_value(_1) + pure_out_value(_2))
			.def("set", &baseclip::set)
			.def("type", &baseclip::type)
	];

	try {
		lua_dostring(L,
			"class 'testclip'(clip)\n"
			"function testclip:__init() super() end\n"
			"function testclip:type2() return 'testclip' end\n"
			"function testclip:type() return clip.type(self)..'(상속버전)' end\n"
			"aa = testclip()\n"
			"print(aa:type2())\n");
		object aa_ = get_globals(L).at("aa");
		cout << call_member<const char *>(aa_, "type2") << endl;
		lua_dostring(L, 
			"print(aa:type())\n");
		cout << call_member<const char *>(aa_, "type") << endl;
		lua_dostring(L, 
			"aa:set(10, 20)\n"
			"print(aa:get())\n");
	}
	catch (error &e) {
		cout << e.what() << endl;
	}

	lua_close(L);
}

실행하면 다음과 같이 실행됩니다. C++에서 상속된 testclip 클래스의 오버라이딩된 type() 함수를 호출하는 것을 알 수 있습니다. 마지막 10 20 출력은 C++ 함수의 매개변수를 사용해서 여러값을 반환하는 lua 함수 인터페이스를 구성한 예제입니다. (luabind의 out_value 정책 사용)

testclip
testclip
clip(상속버전)
clip(상속버전)
10   20