#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",,)<<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“(一闪而过)

 

添加框架引用：

 

四、生成动态库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 ;

}

注意，在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！

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全局函数.

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 =

assert(b.a.m == )

这要求 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", ),

value("my_2nd_enum", ),

value("another_enum", )

]

];

在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 ;

}

}

第二个函数只在编译时用于映射 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)

];

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> >("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 可能被放到不同的编译单元里.

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