vs2010中使用luabind

时间 2019-11-10

标签 vs2010 使用 luabind 栏目 C&C++ 繁體版

原文原文链接

第一部分：在vs2010中生成luabind静态库和动态库linux

1、前期准备 1.安装boostios

下载boost并解压到 D:\mylua\boost_1_56_0，进入 D:\mylua\boost_1_56_0\tools\build 运行 bootstrap.bat文件，先编译 bjam.exe，再使用 bjam.exe编译boost库。（运行bjam.exe编译boost库比较耗时，请耐心等待。）

2.下载并生成lua静态库bootstrap

请参考个人文章《lua如何在VS2010中配置静态库》，网址为：点击打开连接

这里有一个注意事项，那就是luabind咱们若是是下载的是luabind-0.9.1，那么lua要下载5.1版本，貌似5.20也能够，可是我没有去尝试。

解压缩包，例如我解压缩到E:\lua\lua-5.1 (本人为：D:\mylua\lua-5.1.4\src)

(本人使用D:\mylua\lua-5.1.4版本的源代码，由于本人安装的lua版本为lua-5.1.4)

注：本人因引用的lua版本源代码和安装的lua版本不匹配，致使一直出现 “找不到标识符”的错误。引觉得注。

(lua配置环境变量网上查找相关资料，有不少，也简单。)

3.下载luabind源代码安全

下载网址：点击打开连接，解压缩包，例如我解压缩到E:\lua\luabind-0.9.1(本人为：D:\mylua\luabind-0.9.1)

2、生成静态库 框架

1.使用向导生成项目/解决方案编辑器

使用vs2010的向导生成静态库项目，去掉“使用预编译头”复选框，取名叫作luabind_lib,文件夹为E:\lua\luabind_lib

2.添加luabind源代码文件svn

（1）右击工程项目"luabind_lib"的“头文件“文件夹 ->添加->新建筛选器，重命名为detail（其实就是添加一个新的虚拟的分类文件夹）；

（2）右击“detail“文件夹->添加->现有项->选择E:\lua\luabind-0.9.1\luabind-0.9.1\luabind\detail目录下的文件添加；(本人为：D:\mylua\luabind-0.9.1\luabind\detail)

（3）右击”头文件“->添加->现有项->选择E:\lua\luabind-0.9.1\luabind-0.9.1\luabind目录中除detail文件夹以外的文件。(本人为：D:\mylua\luabind-0.9.1\luabind)

（4）右击”源文件“文件夹 ->添加->现有项->选择E:\lua\luabind-0.9.1\luabind-0.9.1\src目录下的全部文件(本人为：D:\mylua\lua-5.1.4\src)

3.添加包含目录函数

由于luabind用的是boost中的模板元编写写的，因此须要包含boost目录，他是链接C++和lua的桥梁，因此须要包含lua，最后还要包含他本身添加luabind源代码文件的目录。

右击luabind_lib项目->属性->配置属性->C/C++->常规->附加包含目录添加：

　　a. luabind 源文件目录：E:\lua\luabind-0.9.1\luabind-0.9.1(注意是外层目录)(本人为：D:\mylua\luabind-0.9.1)

　　b. lua源文件目录：E:\lua\lua-5.1\lua-5.1\src (本人为：D:\mylua\lua-5.1.4\src)

　　c. boost源文件目录：D:\Program Files %28x86%29\bost\boost_1_54_0(这个以前就安装好了)(本人为：D:\mylua\boost_1_56_0)

4.生成静态库工具

右击生成解决方案/项目,生成静态库（C:\Users\Administrator\Documents\Visual Studio 2010\Projects\luabind_lib\Debug目录多了一个静态库：luabind_lib.lib）

3、使用静态库

1.新建一个控制台项目取名luabind_test2 。

2.添加代码：

#include "stdafx.h"

#include <iostream>



extern "C" 
{     
#include "lua.h"     
#include "lualib.h"     
#include "lauxlib.h" 
} 
#include <iostream> 
#include <luabind/luabind.hpp>

using namespace std;



int _tmain(int argc, _TCHAR* argv[])
{
    lua_State *L = ::luaL_newstate();  /* opens Lua */
    luabind::open(L);

    luaL_dostring(L,"function add(first,second)\n return first + second\n end\n");

    try{
        std::cout<<"Result:"
            <<luabind::call_function<int>(L,"add",2,3)<<std::endl;
    }
    catch(luabind::error& e){
        std::cout<<"catch exception:"<<e.what()<<std::endl;
    }
    ::lua_close(L);

}

3.添加包含目录性能

右击luabind_test项目->属性->配置属性->C/C++->常规->附加包含目录添加：

　　a.luabind 源文件目录：E:\lua\luabind-0.9.1\luabind-0.9.1(注意是外层目录)

　　b.lua源文件目录：E:\lua\lua-5.1\lua-5.1\src

　　c.boost源文件目录：D:\Program Files %28x86%29\bost\boost_1_54_0(这个以前就安装好了)

4.添加上面作好的luabind静态库，这里使用直接添加依赖项目：

　　右击解决方案->添加->现有项目->E:\lua\luabind_lib\luabind_lib\luabind_lib\ luabind_lib.vcxproj(本人为：C:\Users\Administrator\Documents\Visual Studio 2010\Projects\luabind_lib\luabind_lib\luabind_lib.vcxproj)

　　设置好依赖关系：在项目luabind_test2上右键 ->项目依赖项->勾选luabind_lib。

　　配置依赖关系：右击luabind-test项目->属性->通用属性->框架和引用->添加新引用->添加的两个静态库

5. 添加lua 静态库(连接器->输入->附加依赖项->添加 lua5.1.lib)，VC++目录(lua 包含目录和库目录(在lua安装路径下))

注：生成成功，会在C:\Users\Administrator\Documents\Visual Studio 2010\Projects\luabind_test2\Debug目录下生成luabind_lib.lib静态库和luabind_test2.exe可执行文件。

编译运行，运行结果”Result:5“(一闪而过)

添加框架引用：

4、生成动态库dll

1. 在VS中新建一个控制台项目，类型为DLL，命名项目为hello_dll_luabind,而后输入一下代码：

#include "stdafx.h"
#include <iostream>
#include <luabind/luabind.hpp>
void greet()
{
    std::cout << "hello world!\n";
}

extern "C" int __declspec(dllexport) init(lua_State* L)
{
    using namespace luabind;

    open(L);

    module(L)
    [
        def("greet", &greet)
    ];

    return 0;
}

注意，在Windows环境下init函数以前是要加__declspec(dllexport)才能将函数导出的，而luabind的文档中的环境是linux，默认不用加__declspec(dllexport)也能够导出(就由于这个折腾了我半天才把hello word成功运行)。

2. 添加静态库文件：将luabind.lib和lua51.lib添加到连接选项中：项目属性->链接器->输入->附加依赖文件，加入luabind.lib和lua51.lib(这里我把luabind.lib拷贝到我工程项目根目录下：C:\Users\Administrator\Documents\Visual Studio 2010\Projects\hello_dll_luabind\luabind_lib.lib)。

接着：在项目->属性->VC++目录->包含目录和库目录中分别添加luabind.lib和lua51.lib所在目录，以及代码中包含文件的目录。同时须要把D:\mylua\boost_1_56_0目录引入(luabind须要用到boost库相关头文件)。以下图：

3.编译运行将在工程项目文件目录 C:\Users\Administrator\Documents\Visual Studio 2010\Projects\hello_dll_luabind\Debug 下获得hello_dll_luabind.dll文件。

4. 把hello_dll_luabind.dll放到lua51.dll和lua.exe所在的目录下。打开lua命令行，键入:

测试成功。cheer！

后补：

1、当我把代码中的init函数名改成luaopen_hello_dll_luabind时(注意和项目工程名同样)，从新生成动态库，拷贝到lua51.dll和lua.exe所在目录，能够以下运行：

bingo！

2、使用Sublime工具来编写lua(本人使用感受挺不错的一款文本编辑器，提供了各类插件对lua的支持，具体网上有不少资料可供参考。)

配置好Sublime以后(使用lua编译系统，svn插件等)，键入以下程序，ctrl+B 运行，结果截图以下：

这里涉及到require在加载模块时的一些规则，详见《lua程序设计（第二版）》

【参考】http://www.aichengxu.com/view/13671

第二部分：luabind使用语法(详细内容可参见《luabind使用手册》)

6 做用域
注册到Lua里面的全部东西要不注册于一个名空间下(Lua table)要不注册于全局做用域(lua module).
全部注册的东西必须放在一个做用域里面.为了定义一个模块, luabind::module 类必须被使用.
使用方式以下:

module(L)
[
// declarations
];

这将会注册全部的函数或者类到 Lua 全局做用域. 若是你想要为你的模块设定一个名空间(相似标准模块),

你能够给构造函数设定一个名字,例如:

module(L, "my_library")
[
// declarations
];

这里全部的申明都将被放置在 my_libary 表.

若是你想要嵌套名空间,你能够用 luabind::namespace_ 类. 它和 luabind::module 相似,除了构造器
没有lua_State* 输入参数.用例以下:

module(L, "my_library")
[
// declarations

namespace_("detail")
[
// library-private declarations
]
];

你可能会想到,下面两个声明是等价的:

module(L)
[
namespace_("my_library")
[
// declarations
]

];
module(L, "my_library")
[
// declarations
];

每个声明必须用逗号分隔,例如:

module(L)
[
def("f", &f),
def("g", &g),
class_<A>("A")
.def(constructor<int, int>),
def("h", &h)
];

更多实际的例子请参阅绑定函数到Lua 和绑定类到Lua 章节.

请注意, (若是你对性能有很高的需求)把你的函数放到表里面将增长查找函数的时间.

7 绑定函数到Lua

为了绑定函数到Lua,你可使用函数 luabind::def(). 它的声明以下:

template<class F, class policies>
void def(const char* name, F f, const Policies&);

* name 是该函数在Lua里面的名字

* F 是该函数的指针
* 策略参数是用来描述怎样处理该函数参数和返回值的.这是一个可选参数,参见策略章节.

下面的例子演示注册函数 float std::sin(float):

module(L)
[
def("sin", &std::sin)
];

7.1 重载函数

若是你有同名函数须要注册到Lua, 你必须显示的给定函数的签名.
这可让C++知道你指定的是哪个函数. 例如, 若是你有两个函数,

int f(const char*) 和 void f(int).
module(L)
[
def("f", (int(*)(const char*)) &f),
def("f", (void(*)(int)) &f)
];

7.2 签名匹配

LuaBind 将会生成代码来检查Lua栈的内容是否匹配你的函数的签名. 它会隐式的在
派生类之间进行类型转换,而且它会按照尽可能少进行隐式类型转换的原则经行匹配.在
一个函数调用中,若是函数是重载过的,而且重载函数的参数匹配分不出好坏的话
(都经行一样次数的隐式类型转换),那么将产生一个二义性错误.这将生成一个运行时
错误,程序挂起在产生二义性调用的地方.一个简单的例子是,注册两个函数,一个函数
接受一个int参数,另一个函数接受一个float参数. 由于Lua将不区别浮点数和整形数,
因此他们都是匹配的.

由于全部的重载是被测试过的,这将老是找到最好的匹配(不是第一个匹配).这样意味着,
LuaBind能够处理签名的区别只是const和非const的重载函数.

例如,若是以下的函数和类被注册:

struct A
{
void f();
void f() const;
};

const A* create_a();全部权转移

为了正确处理全部权转移问题,create_a()将用来适配返回值策略.
参见策略章节.
-Linker Lin 4/5/08 6:32 PM

struct B: A {};
struct C: B {};

void g(A*);
void g(B*);

执行如下 Lua 代码即结果:

a1 = create_a()
a1:f() -- 常量版本被调用

a2 = A()
a2:f() -- 很是量版本被调用

a = A()
b = B()
c = C()

g(a) -- calls g(A*)
g(b) -- calls g(B*)
g(c) -- calls g(B*)

7.3 调用Lua函数

为了调用一个Lua函数, 你能够或者用 call_function() 或者用一个对象(object).

template<class Ret>
Ret call_function(lua_State* L, const char* name, ...)
template<class Ret>
Ret call_function(object const& obj, ...)

call_function()函数有两个重载版本.一个是根据函数的名字来调用函数,

另外一个是调用一个能够做为函数调用的Lua值.

使用函数名来调用的版本只能调用Lua全局函数.

"..."表明传递给Lua函数的可变个数的参数. 这使得你能够指定调用的策略.你能够经过 operator[] 来实现
这个功能.你能够同过方括号来指定策略,例如:

int ret = call_function<int>(
L
, "a_lua_function"
, new complex_class()
)[ adopt(_1) ];

若是你想经过引用方式传递参数,你必须用Boost.Ref来包装一下.

例如:

int ret = call_function(L, "fun", boost::ref(val));

若是你想给一个函数调用指定本身的错误捕获处理函数(error handler),能够参阅

pcall errorfunc 章节的 set_pcall_callback .

7.4 使用Lua协程

为了使用Lua协程,你必须调用 lua_resume(),这就意味着你不能用先前介绍的函数
call_function()来开始一个协程.你必须用这个:

template<class Ret>
Ret resume_function(lua_State* L, const char* name, ...)
template<class Ret>
Ret resume_function(object const& obj, ...)

和:

template<class Ret>
Ret resume(lua_State* L, ...)

第一次开始一个协程的时候,你必须给它一个入口函数. 当一个协程返回(yield)的时候,

resume_fucntion()调用的返回值是 lua_yield()的第一个传入参数.当你想要继续一个
协程的时候,你只须要调用 resume() 在你的 lua_State() 上,由于它已经在执行一个函数
(即先前出入的入口函数),因此你不须要再次传入函数.resume()的传入参数将做为Lua侧的
yield()调用的返回值.

为了暂停(yielding)C++函数,(不支持在C++侧和Lua侧传送数据块),你可使用 yield 策略.

接受 object 参数的resume_function()的重载版本要求对象必须是一个协程对象.(thread)

lua_State* thread = lua_newthread(L);
object fun = get_global(thread)["my_thread_fun"];
resume_function(fun);

8 绑定类到Lua

为了注册一个类,你能够用 class_ 类. 它的名字和C++关键字相似是为了比较直观.它有一个重载
过的成员函数 def() .这个函数被用来注册类的成员函数,操做符,构造器,枚举和属性.它将返回 this
指针,从而方便你直接注册更多的成员.

让咱们开始一个简单的例子.考虑下面的C++类:

class testclass
{
public:
testclass(const std::string& s): m_string(s) {}
void print_string() { std::cout << m_string << "\n"; }

private:
std::string m_string;
};

为了注册这个类到Lua环境,能够像下面这样写(假设你使用了名空间):

module(L)
[
class_<testclass>("testclass")
.def(constructor<const std::string&>())
.def("print_string", &testclass::print_string)
];

这将注册 testclass 类以及接受一个string参数的构造器以及一个成员叫print_string()的函数.

Lua 5.0 Copyright (C) 1994-2003 Tecgraf, PUC-Rio
> a = testclass('a string')
> a:print_string()
a string

还能够注册自由函数做为成员函数.对这个自由函数的要求是,它必须接受该类的一个指针或常量指针或
引用或常量引用做为函数的第一个参数.该函数的剩下的参数将在Lua侧可见,而对象指针将被赋值给第一个
参数.若是咱们有以下的C++代码:

struct A
{
int a;
};

int plus(A* o, int v) { return o->a + v; }

你能够注册 plus() 做为A的一个成员函数,以下:

class_<A>("A")
.def("plus", &plus)

plus() 如今可以被做为A的一个接受一个int参数的成员函数来调用.若是对象指针(this指针)是const,

这个函数也将表现的像一个常量成员函数那样(它能够经过常量对象来调用).

8.1 重载成员函数

当绑定超过一个以上的重载过的成员函数的时候,或只是绑定其中的一个的时候,你必须消除你传递给 def() 的
成员函数指针的歧义.为此,你能够用普通C风格的类型转换来转型匹配正确的重载函数. 为此,你必须知道怎么去
描述C++成员函数的类型.这里有一个简短的教程(更多信息请查阅你的C++参考书):
成员函数指针的语法以下:

return-value (class-name::*)(arg1-type, arg2-type, ...)

例如:

struct A
{
void f(int);
void f(int, int);
};
class_<A>()
.def("f", (void(A::*)(int))&A::f)

A的第一个成员函数f(int)被绑定了,而第二个没哟被绑定.

8.2 属性

很容易注册类的全局数据成员.考虑以下的类:

struct A
{
int a;
};

这个类能够这样注册:

module(L)
[
class_<A>("A")
.def_readwrite("a", &A::a)
];

这使得成员变量 A::a 得到了读写访问权. 还能够注册一个只读的属性:

module(L)
[
class_<A>("A")
.def_readonly("a", &A::a)
];

当绑定成员是一个非原始数据类型的时候,自动生成的 getter 函数将会返回一个它引用.

这就容许你能够链式使用 . 操做符.例如,当有一个结构体包含另一个结构体的时候.以下:

struct A { int m; };
struct B { A a; };

当绑定B到Lua的时候,下面的表达式应该能够工做:

b = B()
b.a.m = 1
assert(b.a.m == 1)

这要求 a 属性必须返回一个A的引用, 而不是一个拷贝. 这样,LuaBind将会自动使用依赖策略来

确保返回值依赖于它所在的对象.因此,若是返回的引用的生命长于该对象的全部的引用(这里是b).
它将保持对象是激活的,从而避免出现悬挂指针.

你还能够注册 getter 或者 setter 函数来使得它们看上去像一个 public 的成员.考虑下面的类:

class A
{
public:
void set_a(int x) { a = x; }
int get_a() const { return a; }

private:
int a;
};

能够这样注册成一个公共数据成员:

class_<A>("A")
.property("a", &A::get_a, &A::set_a)

这样 set_a() 和 get_a() 将取代简单的数据成员操做.若是你想使之只读,你只须要省略最后一个参数.

请注意, get 函数必须是 const 的,不然不能经过编译.

8.3 枚举

若是你的类包含枚举,你能够注册它们到Lua. 注意,它们不是类型安全的,全部的枚举在Lua侧都是整型的,
而且全部接受枚举参数的函数都将接受任何整型.你能够像这样注册它们:

module(L)
[
class_<A>("A")
.enum_("constants")
[
value("my_enum", 4),
value("my_2nd_enum", 7),
value("another_enum", 6)
]
];

在Lua侧,他们能够像数据成员那样被操做,除了它们是只读的并且属于类自己而不是类的实例.

Lua 5.0 Copyright (C) 1994-2003 Tecgraf, PUC-Rio
> print(A.my_enum)
4
> print(A.another_enum)
6

8.4 操做符

为了绑定操做符,你须要包含头文件 <luabind/operator.hpp>.
注册你的类的操做符的机制很是的简单.你经过一个全局名字 luabind::self 来引用类本身,而后你就
能够在def()调用里面直接用操做符表达式. 类以下:

struct vec
{
vec operator+(int s);
};

能够这样注册:

module(L)
[
class_<vec>("vec")
.def(self + int())
];

无论你的 + 操做符是定义在类里面仍是自由函数均可以工做.

若是你的操做符是常量的(const)(或者,是一个自由函数, 接受一个类的常量的引用)你必须用
const_self 替代 self. 以下:

module(L)
[
class_<vec>("vec")
.def(const_self + int())
];

支持以下操做符:

+ - * / == < <=

这意味着,没有"就地操做符"(in-place)(++ --). 相等操做符(==)有些敏锐;若是引用是相等的就不会
被调用. 这意味着, 相等操做符的效率很是好.

Lua不支持操做符包括: !=,>和<=.这是为何你只能注册上面那些操做符. 当你调用这些操做符的时候,
Lua会把调用转换到支持的操做符上.(译注:例如:==和!=有逻辑非的关系) -Linker Lin 4/6/08 11:09 PM

在上面的示例中,操做数的类型是 int().若是操做数的类型是复杂类型,就不是那么简单了,你须要用 other<>
来包装下.例如:
为了注册以下的类,咱们不想用一个string的实例来注册这个操做符.

struct vec
{
vec operator+(std::string);
};

取而代之的是,咱们用 other<> 包装下,以下:

module(L)
[
class_<vec>("vec")
.def(self + other<std::string>())
];

注册一个应用程序操做符(函数调用):

module(L)
[
class_<vec>("vec")
.def( self(int()) )
];

这里有个特殊的操做符.在Lua里,它叫作 __tostring,它不是一个真正的操做符.它是被用来转换一个对象到

string的标准Lua方法.若是你注册之,能够经过Lua的标准函数 tostring() 来转换你的对象到一个string.

为了在C++里实现这个操做符,你须要为 std::ostream 提供 operator<< .像这样:

class number {};
std::ostream& operator<<(std::ostream&, number&);

...

module(L)
[
class_<number>("number")
.def(tostring(self))
];

8.5 嵌套做用域和静态函数

能够添加嵌套的做用域到一个类.当你须要包装一个嵌套类或者一个静态函数的时候就会颇有用.

class_<foo>("foo")
.def(constructor<>()
.scope
[
class_<inner>("nested"),
def("f", &f)
];

在上面的例子里, f 将表现的像一个类 foo 的静态函数,而类 nested 将表现的像类 foo 的嵌套类.

还能够用一样的语法添加名空间到类里面.

8.6 继承类

若是你想要注册一个继承自其它类的类到Lua, 你能够指定一个模板参数 bases<> 给 class_ 的构造器.
以下的继承关系:

struct A {};
struct B : A {};

能够这样注册:

module(L)
[
class_<A>("A"),
class_<B, A>("B")
];

若是你使用了多继承,你能够指定多于一个的基类.若是 B 还继承了类 C , 它能够这样注册:

module(L)
[
class_<B, bases<A, C> >("B")
];

注意,你能够省去 bases<> 当你用的是单继承的时候.

注意
若是你不指定类的继承关系, LuaBind 将不能在相关的继承类型间进行隐式类型转换.

8.7 智能指针

当你注册一个类的时候,你能够告诉 LuaBind 全部的该类的实例应该被某种智能指针持有.(例如: boost::shared_ptr)
你可经过把一个持有器类型模板参数给 class_ 类的构造器来实现该功能.例如:

module(L)
[
class_<A, boost::shared_ptr<A> >("A")
];

你还必须为你的智能指针提供两个函数.一个返回常量版本的智能指针类型(这里是: boost:shared_ptr< const A >).

另外一个函数要能够从智能指针萃取流指针(raw pointer). 之因此须要第一个函数是由于,LuaBind 容许
很是量 -> 转换在传递Lua值到C++的时候.之因此须要第二个函数是由于,当Lua调用一个被智能指针持有
的类的成员函数的时候,this 指针必须是一个流指针.还有一个缘由是,从Lua转换到C++的时候,须要实现
智能指针到普通指针的转换.看上去像这样:

namespace luabind {

template<class T>
T* get_pointer(boost::shared_ptr<T>& p)
{
return p.get();
}

template<class A>
boost::shared_ptr<const A>*
get_const_holder(boost::shared_ptr<A>*)
{
return 0;
}
}

第二个函数只在编译时用于映射 boost::shared_ptr<A>到其常量版本 boost::shared_ptr<const A>.

它历来不会被调用,因此返回值是无所谓的(返回值的类型才是关键).

这个转换将这样工做(假定 B 是A的基类):
从Lua到C++

Source     Target
holder_type<A>     A*
holder_type<A>     B*
holder_type<A>     A const*
holder_type<A>     B const*
holder_type<A>     holder_type<A>
holder_type<A>     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<A>     holder_type<A>
holder_type<A const>     holder_type<A const>
holder_type<A> const&     holder_type<A>
holder_type<A const> const&     holder_type<A const>

当使用持有器类型的时候,知道指针是否是合法(例如:非空)是颇有用的.例如,当使用 std::auto_ptr 的时候,

持有器经过一个参数传递给函数的时候将会变得无效. 为了这个目的,全部的对象实例都有一个成员叫: __ok.

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

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

def("f", &f)
];

> a = X()
> f(a)
> print a.__ok
false

当注册一个继承树的时候,全部的实例被智能指针持有的地方,全部的类必须包含持有器类型.例如:

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

在内部, LuaBind 将会作必要的转换于萃取自持有器的流指针之上.

8.8 拆分类注册

在某些状况下,可能须要分开注册一个类在不一样的编译单元. 部分缘由多是节约重编译时间,而某些编译器的
限制可能要求不得不分开注册一个类.其实很简单.考虑下面的示例代码:

void register_part1(class_<X>& x)
{
x.def();
}

void register_part2(class_<X>& x)
{
x.def();
}

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

register_part1(x);
register_part2(x);

module(L) [ x ];
}

这里,类X被分两步注册.两个函数 register_part 和 register_part2 可能被放到不一样的编译单元里.

关于分开注册一个模块的信息请参阅: 分开注册章节.