本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/olncy/archive/2008/12/15/3520572.aspx

一、服务器组模型的选型        考虑到近年来计算机硬件技术的飞速发展，物理服务器的性价比得到了很大的提高，结合项目需要通过服务器组给数万玩家提供高质量服务的商业要求，经过研究对比数种服务器模型后，决定采取了上图所示的服务器组模型。   二、MMORPG服务器系统架构        MMORPG大型网游服务器是使用高性能网络I/O模型配合消息队列连接各服务线程的一个非常稳定的高性能网游系统。其中消息队列系基于共享内存自行开发完成。在单服务器标准工作环境下进行测试，一台双 XEON 服务器可以非常轻松地达到为4,500用户每秒处理5,000请求，每秒处理请求数可超过225,000。 三、MMORPG的实现        首先，在基础建设方面，与规划现实中的城市一样，得先搭建起一系列的房屋、道路及出口、管线和诸多NPC人物等构成的基本要素和活动空间，通过在服务器端(Server side)取得预先设计好的综合地理、NPC人物、技能等一系列的初始化数字数据(具体文档片段请见附件A.地图数据文件示例和附件B.司机 NPC 数据文件示例)，然后依靠程序将数字数据和游戏逻辑有机地协调起来，最终形成一套完整的虚拟游戏基础空间。          在确定了地图数据生成规则后，就可以使用编辑器任意编辑游戏场景。依赖于这样良好的基础设施，才能在其他游戏逻辑的配合下实现完整的故事情节。同时服务器端负责将属于用户各自的游戏逻辑数据通过验证后发送到合法的用户客户端机器里，完成客户端游戏逻辑的建立和数据同步。担负服务器与客户端通讯的是自定义格式的数据通讯封包，它就像数字神经般贯穿着整个游戏的始终。数据封包与如下4部分消息有关，它们分别为场景消息, 同步消息，主角消息和界面消息。            A.主角消息包括客户端所控制的角色的所有动作，包括走路，聊天、交易、战斗等。            B.场景消息包括昼夜兴替、气候变化，一定的时间在场景里出现某些东西等，这类消息具有的特点是所有消息的发起者都是服务器，广播对象则是场景里的所有玩家。            C.同步消息是针对发起对象是某个玩家，经过服务器广播给所有看得见他的玩家，该消息也包括所有的动作，该种消息是服务器广播给客户端的，主角消息则一般是客户端主动发给服务器端。            D.界面消息是服务器发给客户端的聊天消息和各种属性及状态变化的信息。          值得一谈的还有处于网络游戏中比较重要的服务器同客户端消息广播和同步问题。其中一种方法是采取在国际上被称为 Mutual synchronization（相互同步），是一种对未来网络的前景的良好预测出来的解决方案来解决确保每个玩家在各自客户端上看到的东西大体是一样的同步问题。          首先客户端需要在登录游戏的时候建立很多张广播列表，这些列表在客户端后台和服务器端要保持不定时同步。其中要建立多张列表，是因为要广播的类型包括全局信息、本地信息和远程信息等等，这些列表都是在客户端登陆的时候根据服务器发过来的消息建立好的。在建立列表的同时，还需要获得每个列表中广播对象的传输时间，并且要维护一张完整的用户状态列表在后台，也是进行不定时的和服务器进行同步，根据本地的用户状态表，可以使一部分决策由客户端来决定，当客户端发送这部分决策的时候，则直接将最终决策发送到各个广播列表里面的客户端，并对其时间进行校对，以保证每个客户端在收到的消息的时间是和本地时间进行校对过的，再采用预测补偿计算提前量的方法，计算出提前量，根据计算量确定实际行走速度，将会使同步变得非常的平滑。          其中，广播的重点就在于如何计算出广播的对象，首先在服务器端的连接结构里面增加一个广播对象的队列，该队列在客户端登陆服务器的时候由服务器传输给合法的客户端，然后由客户端自己来维护这个队列，当有人走出客户端视野的时候，由客户端主动要求服务器给那个对象发送消失的消息。          当有人走进视野的情况，则先需要客户端在每次给服务器发送更新位置的消息的时候，服务器都给该连接算出一个视野范围，然后在需要广播的时候，循环整张地图上的玩家，找到坐标在其视野范围内的玩家从而完成广播的全过程。          其次是虚拟对象系统。其中主要会涉及到NPC的概念，尤其是广泛应用的A Star算法等在提供NPC的人工智能决策方面有着重要的作用。NPC智能使用一种是被动触发事件和是主动触发事件的方式由计算机来实现对NPC做何种决策。A Star算法就是典型的启发式搜索的应用，其普通原理是先设计一个Rule() 函数，来获这一个点的代价，然后每次搜索的时候把下一步可能到达的所有点都经过Rule() 函数评价一下，获取两到三个代价比较小的点，继续搜索，直至得到代价最小的一个点。最明显的应用是NPC在实现自动选择攻击目标和逃跑时的实现。实现自动选择攻击目标时，首先获得地图上距离该NPC附近的敌人列表，设计相应Rule() 函数，根据敌人的强弱、远近，判断出几个评估数据，然后选择代价最小的敌人进行主动攻击。逃跑则是在主动事件里面检查自己的HP，如果HP低于某个值，而敌人正近战攻击的时候，则触发逃跑函数，在逃跑函数里面也是对周围的所有的敌人组织成列表，然后设计Rule() 函数，先分析选择出对你构成威胁最大的敌人，该函数还需要判断敌人的运动速度，战斗力强弱，最后得出一个主要敌人，然后针对该主要敌人进行路径的Rule() 的函数的设计，搜索的范围只可能是和主要敌人相反的方向，然后再根据该几个方向上的敌人的强弱来计算代价，做出最后的选择，如果幸运的话，可以有80%的机率逃往没有 NPC 阻挡的邻近地图中去。          最后，由于脚本是RPG游戏的灵魂，自然脚本编译器就扮演了十分重要的地位。在基于编译的服务器端程序中，是无法在程序的运行过程中构建一些东西的，所以必须通过脚本编译器提供一些简单的语法和文法解析的功能，进行一系列的逻辑判断和循环，以提高服务器端的灵活程度。可使用类似汇编语言的那种结构来实现脚本编译器，设置一些条件跳转和循环来实现逻辑判断和循环。提供一些通用指令，如判断、循环、四则运算、寻址等等，针对不同的脚本采用不同的解析方法，对NPC就用NPC固定的脚本，对Item就用Item固定的脚本，解析完以后就把结果生成底层该对象的结构便于使用。          经过以上的建设步骤，一个完整的MMORPG网络游戏系统就被逐步建立起来了。 ZZ MDNA网络游戏整体架构编程

转载： http://www.d2-life.com/LBS/blogview.asp?logID=41

　　使用Lua作脚本，主要是因为它小巧玲珑（体积小，运行快），而且它的语法又比较简单明了。不过，使用LuaAPI将Lua引擎集成到程序中，确实有一些不方便——用落木随风网友的话来说，就是"就象用汇编"。当然，现在你不用再这么辛苦了，因为你可以使用LuaWrapper For C++。使用这个工具，在C++中集成Lua脚本就是轻而易举的事。你原有的C++函数和类，几乎不需要任何改变，就可以与Lua脚本共享。

作者： 沐枫 （第二人生成员）
版权所有转载请注明原出处
主页：第二人生 http://www.d2-life.com
　　　http://www.d2-life.com/LBS/blogview.asp?logID=41

为什么要用Lua作脚本？
　　使用Lua作脚本，主要是因为它小巧玲珑（体积小，运行快），而且它的语法又比较简单明了。不过，使用LuaAPI将Lua引擎集成到程序中，确实有一些不方便——用落木随风网友的话来说，就是"就象用汇编"。当然，现在你不用再这么辛苦了，因为你可以使用LuaWrapper For C++。使用这个工具，在C++中集成Lua脚本就是轻而易举的事。你原有的C++函数和类，几乎不需要任何改变，就可以与Lua脚本共享。
　　我们接下来，用实例来说明，如何用LuaWrapper来集成Lua脚本到你的程序中去。

1.  创建Lua引擎
　　LuaWrap lua; 或者 LuaWrap* lua = new LuaWrap;
　　创建一个LuaWrap对象，就是创建一个Lua脚本引擎。并且根据Lua的特性，你可以创建任意多个Lua引擎，甚至可以分布在不同的线程当中。

2.  装载并执行脚本程序
　　你可以从缓冲区中装载Lua脚本：
　　lua.LoadString(
　　　　"print('Hello World')"
　　);
　　当然，你也可以从文件中装入，并执行Lua脚本：
　　Lua.LoadFile("./test.lua");
　　Lua的脚本，可以是源代码，也可以经过编译后的中间代码。也许你对编译后的中间代码更感兴趣——如果你不希望让源代码赤裸裸的袒露在大家的眼前。

3.  获取和设置Lua变量
　　能够获取和设置脚本变量的内容，是一个最基本的功能。你可以使用GetGlobal和SetGlobal函数来做到这一点：
　　(1)  获取变量：
　　　　int a = lua.GetGlobal<int>("a");
　　　　LuaTable table = lua.GetGlobal<LuaTable>("t");
　　　　这里，<> 里头的类型，就是想要的变量的类型。
　　(2)  设置变量：
　　　　lua.SetGlobal("a", a);
　　　　lua.SetGlobal("t", table);

4.  调用Lua函数
　　使用Call函数，就可以很简单的从你的程序中调用Lua函数：
　　lua.Call<void>("print", "Hello World");
　　int sum = lua.Call<int>("add", 2, 3);
　　这里，<> 里头的类型是返回值的类型。

5.  如何让Lua也能调用C++的函数
　　精采的地方来了。假如有下面这样的一个函数：
　　int add(int a, int b)
　　{
　　　　return a + b;
　　}
　　如果想让它能够让Lua使用，只需将它注册到Lua引擎当中就可以了：
　　lua.RegisterFunc("add", int(int,int), add);
　　这样，Lua中就可以用直接使用了：
　　（Lua脚本）sum = add(1, 3)

　　(*) RegisterFunc的功能，就是让你把C++的函数注册到Lua中，供Lua脚本使用。
　　　　第一个参数，是想要在Lua中用的函数名。
　　　　第二个参数，是C++中函数的原型； C++允许函数重载的，你可以使用函数原型，来选择需要注册到Lua引擎中的那个函数。
　　　　第三个参数，就是C++中函数的指针了。

6.  如何能让C++的类在Lua中使用
　　我们先看看下面这个C++类：
class MyArray
{
  std::vector<double> array;
public:
  void setvalue(int index, double value);
  double getvalue(int index);
  int size();
  const char* ToString();
};

　　你准备要让Lua能够自由访问并操作这个类。很简单，你只需增加几个宏定义就可以了：

class MyArray
{
  std::vector<double> array;
public:
  void setvalue(int index, double value);
  double getvalue(int index);
  int size();
  const char* ToString();
  // 将一个 class 作为一个 Lua 对象是很容易的，只需要增加以下宏定义。
  DEFINE_TYPENAME("My.array");
  BEGIN_REGLUALIB("array")
      LUALIB_ITEM_CREATE("new", MyArray )  // 创建MyArray 
      LUALIB_ITEM_DESTROY("del", MyArray )  // 消除MyArray。
  END_REGLUALIB()
  BEGIN_REGLUALIB_MEMBER()
    LUALIB_ITEM_FUNC("size", int (MyArray*), &MyArray::size)
    LUALIB_ITEM_FUNC("__getindex", double(MyArray*, int), &MyArray::getvalue)  
    LUALIB_ITEM_FUNC("__newindex", void (MyArray*, int, double), &MyArray::setvalue)
    LUALIB_ITEM_FUNC("__tostring", const char* (MyArray*), &MyArray::ToString)
    LUALIB_ITEM_DESTROY("__gc", MyArray )   // 垃圾收集时消除对象用。
  END_REGLUALIB_MEMBER()
};

　　只要有了这些宏定义，这个类就是可以在Lua中使用的类了，我们就可以在Lua中注册这个类了：
　　lua.Register<MyArray>()

　　这样注册以后，我们在Lua中就可以使用这个类了：
　　a = array.new()  -- 创建对象，相当于 a = new Myarray
　　a[1] = 10  -- 调用__newindex，也就是C++中的 a->setvalue(1, 10)
　　a[2] = 20  -- 调用__newindex，也就是C++中的 a->setvalue(2, 20)
　　print(
　　　　a,  -- 调用 __tostring，也就是C++中的 a->ToString()
　　　　a:size(), -- 相当于C++中的 a->size()
　　　　a[1], -- 调用__getindex，也就是C++中的a->getvalue(1)
　　　　a[2]) --调用__getindex，也就是C++中的a->getvalue(2)
　　array.del(a)  -- 清除对象，相当于 delete a
　　a = nil  -- 清空 a，很象C++中的 a = NULL

　　当然，你也可以不用del这个对象，而是等待Lua帮你自动进行垃圾回收。在Lua进行垃圾回收时，它会自动调用这个对象的 __gc ，相当于 delete。

　　那么，在C++中要创建MyArray对象，并且传递给Lua全局变量怎么办？就象前面讲过的一样，使用SetGlobal：
　　MyArray* a = new MyArray;
　　lua.SetGlobal("a", a);
　　要获取该对象，同样的，应该使用GetGlobal：
　　MyArray* a = lua.GetGlobal<MyArray>("a");
　　
　　对于传递给Lua的对象，就让Lua来管理该对象的生存周期好了。如果你非要删除它的话，你可以使用DelGlobalObject：
　　lua.DelGlobalObject<MyArray>("a");
　　不过这么做的话，你应当明白你在做什么，因为在Lua的脚本中，可能已经在多处引用了这个对象了。删除了其中一个，将导致其它引用对象失效，从而可能引致系统崩溃。

　　(1)  DEFINE_TYPENAME("My.array");
　　　　定义类型的名称。在Lua中，这个类型名称是唯一用来识别C++类型的，你必须为不同的对象给予不同的名称。

　　(2)  BEGIN_REGLUALIB("array") ... END_REGLUALIB()
　　　　你可以为一个对象定义一个程序库，"array"就是程序库的名字。在程序库中定义的函数是全局函数，在Lua中，使用该函数，需要在函数前加上库的名字，如：array.new（）。通常，程序库会包含创建对象的方法。如：
　　　　LUALIB_ITEM_CREATE("new", MyArray )  // 创建MyArray

　　　　这样子，你才能在Lua中创建MyArray：
　　　　a = array.new()
　　
　　　　你也可以选择增加一个删除对象操作：
　　　　LUALIB_ITEM_DESTROY("del", MyArray )   // 删除MyArray
　　　　这样，你就可以直接删除一个对象了：
　　　　array.del(a)

　　(3)  BEGIN_REGLUALIB_MEMBER() ...END_REGLUALIB_MEMBER()
　　　　在此处，你可以定义对象的成员函数，也可以重载对象的操作符——是的，就象C++的operator重载。例如：
　　　　LUALIB_ITEM_FUNC("__newindex", void (MyArray*, int, double), &MyArray::setvalue)
　　　　就是重载 operator[] 操作符。Lua中可重载的操作符还有许多，如：

　　　　__getindex：操作符[]，支持读取访问，如 v = a[10]
　　　　__newindex：操作符[]，支持赋值访问，如 a[10] = 1.22
　　　　__tostring：将变量转换成字串__add：等同于operator +
　　　　__add：操作符 ＋
　　　　__sub：操作符 -
　　　　__mul：操作符 ×
　　　　__div：操作符 ÷
　　　　__pow：操作符 ^ (乘方)
　　　　__unm：一元操作符 -
　　　　__concat：操作符 .. (字符串连接)
　　　　__eq：操作符 == (a ~= b等价于 not a == b)
　　　　__lt：操作符 < (a > b 等价于 b < a)
　　　　__le：操作符 <= (a >= b 等价于 b <= a，要注意的是，如果没有定义"__le"，则Lua将会尝试将a<=b 转换成 not (b < a) )

　　　　__gc：在垃圾回收时调用此函数，相当于C++的析构函数。强烈建议定义此操作符，以免造成内存泄漏等情况。比如：
　　　　LUALIB_ITEM_DESTROY("__gc", MyArray )   // 垃圾收集时消除对象用。

　　　　(注) 这里要说明一下，在lua中，访问索引操作符是__index，不是__getindex，在luaWrapper库中，为了方便使用，将其映射为__getindex，同时，对__index的定义将会被忽略。

　　　　就这么简单。假如你已经有现成的类，而你没有修改该类的权力，如何将其加入到Lua中呢？答案就是，继承它，将把派生类加入到Lua中。

结束语
　　LuaWrapper 需要用到boost库的支持：boost/type_traits.hpp, boost/function.hpp, boost/bind.hpp，它使用了C++的模板部份特化，因此，C++编译器如果不支持此特性，将无法编译。目前支持此特性的编译器已经有很多。在VisualStudo产品系列中，只有VC7.1能支持此特性，因此，您如果正在使用VisualStudio，请确认你用的是VisualStudio2003。
　　如果你觉得 LuaWrapper For C++ 能够帮助你，我会感觉很荣幸。我很愿意将这个程序库分享给大家。顺便一提的是，如果你在使用过程中发现BUG，或是有好的建议，希望您能与我联系。你在使用过程中，请不要删除文件中的署名信息；如果你修改了程序库，请您在修改的文件中加入您的修改说明。当然，我会非常欢迎您能将修改后的程序回馈给我。我会继续优化并完善它。

使用 Lua 编写可嵌入式脚本

Lua 提供了高级抽象，却又没失去与硬件的关联

将此页作为电子邮件发送 级别: 初级 Martin Streicher (martin.streicher@linux-mag.com), 首席编辑, Linux Magazine 2006 年 6 月 12 日 虽然编译性编程语言和脚本语言各自具有自己独特的优点，但是如果我们使用这两种类型的语言来编写大型的应用程序会是什么样子呢？Lua 是一种嵌入式脚本语言，它非常小，速度很快，功能却非常强大。在创建其他配置文件或资源格式（以及与之对应的解析器）之前，请尝试一下 Lua。 尽管诸如 Perl、Python、PHP 和 Ruby 之类的解释性编程语言日益被 Web 应用程序广泛地采纳 —— 它们已经长期用来实现自动化系统管理任务 —— 但是诸如 C、C++ 之类的编译性编程语言依然是必需的。编译性编程语言的性能是脚本语言所无法企及的（只有手工调优的汇编程序的性能才能超过它），有些软件 —— 包括操作系统和设备驱动程序 —— 只能使用编译代码来高效地实现。实际上，当软件和硬件需要进行无缝地连接操作时，程序员本能地就会选择 C 编译器：C 非常基础，距离 “原始金属材料非常近” —— 即可以操作硬件的很多特性 —— 并且 C 的表现力非常强大，可以提供高级编程结构，例如结构、循环、命名变量和作用域。 然而，脚本语言也有自己独特的优点。例如，当某种语言的解释器被成功移植到一种平台上以后，使用这种语言编写的大量脚本就可以不加任何修改在这种新平台上运行 —— 它们没有诸如系统特定的函数库之类的依赖限制。（我们可以考虑一下 Microsoft® Windows® 操作系统上的许多 DLL 文件和 UNIX® 及 Linux® 上的很多 libcs）。另外，脚本语言通常都还会提供高级编程构造和便利的操作，程序员可以使用这些功能来提高生产效率和灵活性。另外，使用解释语言来编程的程序员工作的速度更快，因为这不需要编译和链接的步骤。C 及其类似语言中的 “编码、编译、链接、运行” 周期缩减成了更为紧凑的 “编写脚本、运行”。 Lua 新特性 与其他脚本语言一样，Lua 也有自己的一些特性： Lua 类型。在 Lua 中，值可以有类型，但是变量的类型都是动态决定的。nil、布尔型、数字 和 字符串 类型的工作方式与我们期望的一样。 Nil 是值为 nil 的一种特殊类型，用来表示没有值。 布尔型的值可以是 true 和 false 常量。（Nil 也可以表示 false，任何非 nil 的值都表示 true。） Lua 中所有的数字都是双精度的（不过我们可以非常简便地编写一些代码来实现其他数字类型）。 字符串是定长字符数组。（因此，要在一个字符串后面附加上字符，必须对其进行拷贝。） 表、函数 和线程 类型都是引用。每个都可以赋值给一个变量，作为参数传递，或作为返回值从函数中返回。例如，下面是一个存储函数的例子： -- example of an anonymous function -- returned as a value -- see http://www.tecgraf.puc-rio.br/~lhf/ftp/doc/hopl.pdf function add(x) return function (y) return (x + y) end end f = add(2) print(type(f), f(10)) function 12 Lua 线程。线程是通过调用内嵌函数 coroutine.create(f) 创建的一个协同例程 (co-routine)，其中 f 是一个 Lua 函数。线程不会在创建时启动；相反，它是在创建之后使用 coroutine.resume(t) 启动的，其中 t 就是一个线程。每个协同例程都必须使用 coroutine.yield() 偶尔获得其他协同例程的处理器。 赋值语句。Lua 允许使用多种赋值语句，可以先对表达式进行求值，然后再进行赋值。例如，下面的语句： i = 3 a = {1, 3, 5, 7, 9} i, a[i], a[i+1], b = i+1, a[i+1], a[i] print (i, a[3], a[4], b, I) 会生成 4 7 5 nil nil。如果变量列表的个数大于值列表的个数，那么多出的变量都被赋值为 nil；因此，b 就是 nil。如果值的个数多于变量的个数，那么多出的值部分就会简单地丢弃。在 Lua 中，变量名是大小写敏感的，这可以解释为什么 I 的值是 nil。 块（Chunk）。 块 可以是任何 Lua 语句序列。块可以保存到文件中，或者保存到 Lua 程序中的字符串中。每个块都是作为一个匿名函数体来执行的。因此，块可以定义局部变量和返回值。 更酷的东西。Lua 具有一个标记-清理垃圾收集器。在 Lua 5.1 中，垃圾收集器是以增量方式工作的。Lua 具有完整的词法闭包（这与 Scheme 类似，而与 Python 不同）。Lua 具有可靠的尾部调用语义（同样，这也与 Scheme 类似，而与 Python 不同）。 在 Programming in Lua 和 Lua-users wiki （链接请参见后面的 参考资料 部分）中可以找到更多 Lua 代码的例子。 在所有的工程任务中，要在编译性语言和解释性语言之间作出选择，就意味着要在这种环境中对每种语言的优缺点、权重和折中进行评测，并接受所带来的风险。 回页首 在两个世界之间最好地进行混合 如果您希望充分利用这两个世界的优点，应该怎样办呢，是选择最好的性能还是选择高级强大的抽象？更进一步说，如果我们希望对处理器密集且依赖于系统的算法和函数以及与系统无关且很容易根据需要而进行修改的单独逻辑进行优化，那又当如何呢？ 对高性能代码和高级编程的需要进行平衡是 Lua（一种可嵌入式脚本语言）要解决的问题。在需要时我们可以使用编译后的代码来实现底层的功能，然后调用 Lua 脚本来操作复杂的数据。由于 Lua 脚本是与编译代码独立的，因此我们可以单独修改这些脚本。使用 Lua，开发周期就非常类似于 “编码、编译、运行、编写脚本、编写脚本、编写脚本 ...”。 例如，Lua Web 站点 “使用” 页面（请参见 参考资料）列出了主流市场上的几个计算机游戏，包括 World of Warcraft 和（家用版的）Defender，它们集成 Lua 来实现很多东西，从用户界面到敌人的人工智能都可以。Lua 的其他应用程序包括流行的 Linux 软件更新工具 apt-rpm 的扩展机制，还有 “Crazy Ivan” Robocup 2000 冠军联赛的控制逻辑。这个页面上的很多推荐感言都对 Lua 的小巧与杰出性能赞不绝口。 回页首 开始使用 Lua Lua 5.0.2 版本是撰写本文时的最新版本，不过最近刚刚发布了 5.1 版本。您可以从 lua.org 上下载 Lua 的源代码，在 Lua-users wiki（链接请参见 参考资料）上可以找到预先编译好的二进制文件。完整的 Lua 5.0.2 核心文件中包括了标准库和 Lua 编译器，不过只有 200KB 大小。 如果您使用的是 Debian Linux，那么可以以超级用户的身份运行下面的命令来快速安装 Lua 5.0： # apt-get install lua50 本文中给出的例子都是在 Debian Linux Sarge 上运行的，使用的是 Lua 5.0.2 和 2.4.27-2-686 版本的 Linux 内核。 在系统上安装好 Lua 之后，我们可以首先来试用一下单独的 Lua 解释器。（所有的 Lua 应用程序必须要嵌入到宿主应用程序中。解释器只是一种特殊类型的宿主，对于开发和调试工作来说非常有用。）创建一个名为 factorial.lua 的文件，然后输入下面的代码： -- defines a factorial function function fact (n) if n == 0 then return 1 else return n * fact(n-1) end end print("enter a number:") a = io.read("*number") print(fact(a)) factorial.lua 中的代码 —— 更确切地说是任何 Lua 语句序列 —— 都称为一个块，这在上面的 Lua 特性 中已经进行了介绍。要执行刚才创建的代码块，请运行命令 lua factorial.lua： $ lua factorial.lua enter a number: 10 3628800 或者像在其他解释性语言中一样，我们可以在代码顶部添加一行 “标识符”（#!），使这个脚本变成可执行的，然后像单独命令一样来运行这个文件： $ (echo '#! /usr/bin/lua'; cat factorial.lua) > factorial $ chmod u+x factorial $ ./factorial enter a number: 4 24 回页首 Lua 语言 Lua 具有现代脚本语言中的很多便利：作用域，控制结构，迭代器，以及一组用来处理字符串、产生及收集数据和执行数学计算操作的标准库。在 Lua 5.0 Reference Manual 中有对 Lua 语言的完整介绍（请参见 参考资料）。 在 Lua 中，只有值 具有类型，而变量的类型是动态决定的。Lua 中的基本类型（值）有 8 种： nil，布尔型，数字，字符串，函数，线程，表 以及 用户数据。前 6 种类型基本上是自描述的（例外情况请参见上面的 Lua 特性 一节）；最后两个需要一点解释。 Lua 表 在 Lua 中，表是用来保存所有数据的结构。实际上，表是 Lua 中惟一的 数据结构。我们可以将表作为数组、字典（也称为散列 或联合数组）、树、记录，等等。 与其他编程语言不同，Lua 表的概念不需要是异构的：表可以包含任何类型的组合，也可以包含类数组元素和类字典元素的混合体。另外，任何 Lua 值 —— 包括函数或其他表 —— 都可以用作字典元素的键值。 要对表进行浏览，请启动 Lua 解释器，并输入清单 1 中的黑体显示的代码。 清单 1. 体验 Lua 表 $ lua > -- create an empty table and add some elements > t1 = {} > t1[1] = "moustache" > t1[2] = 3 > t1["brothers"] = true > -- more commonly, create the table and define elements > all at once > t2 = {[1] = "groucho", [3] = "chico", [5] = "harpo"} > t3 = {[t1[1]] = t2[1], accent = t2[3], horn = t2[5]} > t4 = {} > t4[t3] = "the marx brothers" > t5 = {characters = t2, marks = t3} > t6 = {["a night at the opera"] = "classic"} > -- make a reference and a string > i = t3 > s = "a night at the opera" > -- indices can be any Lua value > print(t1[1], t4[t3], t6[s]) moustache the marx brothers classic > -- the phrase table.string is the same as table["string"] > print(t3.horn, t3["horn"]) harpo harpo > -- indices can also be "multi-dimensional" > print (t5["marks"]["horn"], t5.marks.horn) harpo harpo > -- i points to the same table as t3 > = t4[i] the marx brothers > -- non-existent indices return nil values > print(t1[2], t2[2], t5.films) nil nil nil > -- even a function can be a key > t = {} > function t.add(i,j) >> return(i+j) >> end > print(t.add(1,2)) 3 > print(t['add'](1,2)) 3 > -- and another variation of a function as a key > t = {} > function v(x) >> print(x) >> end > t[v] = "The Big Store" > for key,value in t do key(value) end The Big Store 正如我们可能期望的一样，Lua 还提供了很多迭代器函数来对表进行处理。全局变量 table 提供了这些函数（是的，Lua 包就是表）。有些函数，例如 table.foreachi()，会期望一个从 1（数字 1）开始的连续整数范围： > table.foreachi(t1, print) 1 moustache 2 3 另外一些函数，例如 table.foreach()，会对整个表进行迭代： > table.foreach(t2,print) 1 groucho 3 chico 5 harpo > table.foreach(t1,print) 1 moustache 2 3 brothers true 尽管有些迭代器对整数索引进行了优化，但是所有迭代器都只简单地处理 (key, value) 对。 现在我们可以创建一个表 t，其元素是 {2, 4, 6, language="Lua", version="5", 8, 10, 12, web="www.lua.org"}，然后运行 table.foreach(t, print) 和 table.foreachi(t, print)。 用户数据 由于 Lua 是为了嵌入到使用另外一种语言（例如 C 或 C++）编写的宿主应用程序中，并与宿主应用程序协同工作，因此数据可以在 C 环境和 Lua 之间进行共享。正如 Lua 5.0 Reference Manual 所说，userdata 类型允许我们在 Lua 变量中保存任意的 C 数据。我们可以认为 userdata 就是一个字节数组 —— 字节可以表示指针、结构或宿主应用程序中的文件。 用户数据的内容源自于 C，因此在 Lua 中不能对其进行修改。当然，由于用户数据源自于 C，因此在 Lua 中也没有对用户数据预定义操作。不过我们可以使用另外一种 Lua 机制来创建对 userdata 进行处理的操作，这种机制称为 元表（metatable）。 元表 由于表和用户数据都非常灵活，因此 Lua 允许我们重载这两种类型的数据的操作（不能重载其他 6 种类型）。元表 是一个（普通的）Lua 表，它将标准操作映射成我们提供的函数。元表的键值称为事件；值（换而言之就是函数）称为元方法。 函数 setmetatable() 和 getmetatable() 分别对对象的元表进行修改和查询。每个表和 userdada 对象都可以具有自己的元表。 例如，添加操作对应的事件是 __add。我们可以推断这段代码所做的事情么？ -- Overload the add operation -- to do string concatenation -- mt = {} function String(string) return setmetatable({value = string or ''}, mt) end -- The first operand is a String table -- The second operand is a string -- .. is the Lua concatenate operator -- function mt.__add(a, b) return String(a.value..b) end s = String('Hello') print((s + ' There ' + ' World!').value ) 这段代码会产生下面的文本： Hello There World! 函数 String() 接收一个字符串 string，将其封装到一个表（{value = s or ''}）中，并将元表 mt 赋值给这个表。函数 mt.__add() 是一个元方法，它将字符串 b 添加到在 a.value 中找到的字符串后面 b 次。这行代码 print((s + ' There ' + ' World!').value ) 调用这个元方法两次。 __index 是另外一个事件。__index 的元方法每当表中不存在键值时就会被调用。下面是一个例子，它记住 (memoize) 函数的值： -- code courtesy of Rici Lake, rici@ricilake.net function Memoize(func, t) return setmetatable( t or {}, {__index = function(t, k) local v = func(k); t[k] = v; return v; end } ) end COLORS = {"red", "blue", "green", "yellow", "black"} color = Memoize( function(node) return COLORS[math.random(1, table.getn(COLORS))] end ) 将这段代码放到 Lua 解释器中，然后输入 print(color[1], color[2], color[1])。您将会看到类似于 blue black blue 的内容。 这段代码接收一个键值 node，查找 node 指定的颜色。如果这种颜色不存在，代码就会给 node 赋一个新的随机选择的颜色。否则，就返回赋给 node 的颜色。在前一种情况中，__index 元方法被执行一次以分配一个颜色。后一种情况比较简单，所执行的是快速散列查找。 Lua 语言提供了很多其他功能强大的特性，所有这些特性都有很好的文档进行介绍。在碰到问题或希望与专家进行交谈时，请连接 Lua Users Chat Room IRC Channel（请参见 参考资料）获得非常热心的支持。 回页首 嵌入和扩展 除了语法简单并且具有功能强大的表结构之外，Lua 的强大功能使其可以与宿主语言混合使用。由于 Lua 与宿主语言的关系非常密切，因此 Lua 脚本可以对宿主语言的功能进行扩充。但是这种融合是双赢的：宿主语言同时也可以对 Lua 进行扩充。举例来说，C 函数可以调用 Lua 函数，反之亦然。 Lua 与宿主语言之间的这种共生关系的核心是宿主语言是一个虚拟堆栈。虚拟堆栈与实际堆栈类似，是一种后进先出（LIFO）的数据结构，可以用来临时存储函数参数和函数结果。要从 Lua 中调用宿主语言的函数（反之亦然），调用者会将一些值压入堆栈中，并调用目标函数；被调用的函数会弹出这些参数（当然要对类型和每个参数的值进行验证），对数据进行处理，然后将结果放入堆栈中。当控制返回给调用程序时，调用程序就可以从堆栈中提取出返回值。 实际上在 Lua 中使用的所有的 C 应用程序编程接口（API）都是通过堆栈来进行操作的。堆栈可以保存 Lua 的值，不过值的类型必须是调用程序和被调用者都知道的，特别是向堆栈中压入的值和从堆栈中弹出的值更是如此（例如 lua_pushnil() 和 lua_pushnumber()。 清单 2 给出了一个简单的 C 程序（节选自 参考资料 中 Programming in Lua 一书的第 24 章），它实现了一个很小但却功能完善的 Lua 解释器。 清单 2. 一个简单的 Lua 解释器 1 #include <stdio.h> 2 #include <lua.h> 3 #include <lauxlib.h> 4 #include <lualib.h> 5 6 int main (void) { 7 char buff[256]; 8 int error; 9 lua_State *L = lua_open(); /* opens Lua */ 10 luaopen_base(L); /* opens the basic library */ 11 luaopen_table(L); /* opens the table library */ 12 luaopen_io(L); /* opens the I/O library */ 13 luaopen_string(L); /* opens the string lib. */ 14 luaopen_math(L); /* opens the math lib. */ 15 16 while (fgets(buff, sizeof(buff), stdin) != NULL) { 17 error = luaL_loadbuffer(L, buff, strlen(buff), "line") || 18 lua_pcall(L, 0, 0, 0); 19 if (error) { 20 fprintf(stderr, "%s", lua_tostring(L, -1)); 21 lua_pop(L, 1); /* pop error message from the stack */ 22 } 23 } 24 25 lua_close(L); 26 return 0; 27 } 第 2 行到第 4 行包括了 Lua 的标准函数，几个在所有 Lua 库中都会使用的方便函数以及用来打开库的函数。第 9 行创建了一个 Lua 状态。所有的状态最初都是空的；我们可以使用 luaopen_...() 将函数库添加到状态中，如第 10 行到第 14 行所示。 第 17 行和 luaL_loadbuffer() 会从 stdin 中以块的形式接收输入，并对其进行编译，然后将其放入虚拟堆栈中。第 18 行从堆栈中弹出数据并执行之。如果在执行时出现了错误，就向堆栈中压入一个 Lua 字符串。第 20 行访问栈顶（栈顶的索引为 -1）作为 Lua 字符串，打印消息，然后从堆栈中删除该值。 使用 C API，我们的应用程序也可以进入 Lua 状态来提取信息。下面的代码片段从 Lua 状态中提取两个全局变量： .. if (luaL_loadfile(L, filename) || lua_pcall(L, 0, 0, 0)) error(L, "cannot run configuration file: %s", lua_tostring(L, -1)); lua_getglobal(L, "width"); lua_getglobal(L, "height"); .. width = (int) lua_tonumber(L, -2); height = (int) lua_tonumber(L, -1); .. 请再次注意传输是通过堆栈进行的。从 C 中调用任何 Lua 函数与这段代码类似：使用 lua_getglobal() 来获得函数，将参数压入堆栈，调用 lua_pcall()，然后处理结果。如果 Lua 函数返回 n 个值，那么第一个值的位置在堆栈的 -n 处，最后一个值在堆栈中的位置是 -1。 反之，在 Lua 中调用 C 函数也与之类似。如果您的操作系统支持动态加载，那么 Lua 可以根据需要来动态加载并调用函数。（在必须使用静态加载的操作系统中，可以对 Lua 引擎进行扩充，此时调用 C 函数时需要重新编译 Lua。） 回页首 结束语 Lua 是一种学习起来容易得难以置信的语言，但是它简单的语法却掩饰不了其强大的功能：这种语言支持对象（这与 Perl 类似），元表使表类型具有相当程度的可伸展性，C API 允许我们在脚本和宿主语言之间进行更好的集成和扩充。Lua 可以在 C、C++、C#、Java™ 和 Python 语言中使用。 在创建另外一个配置文件或资源格式（以及相应的处理程序）之前，请尝试一下 Lua。Lua 语言及其社区非常健壮，具有创新精神，随时准备好提供帮助。 回页首 参考资料 学习 您可以参阅本文在 developerWorks 全球站点上的 英文原文。 Reference manual for Lua 5.0 介绍了 Lua 语言的完整知识。 Roberto Ierusalimschy 所著的 Programming in Lua（Roberto Ierusalimschy，2003 年）是学习如何使用 Lua 有效地进行编码的非常有用的资源。 请参阅 Lua-users wiki 中的 library of Lua 教程，学习如何使用 Lua 的特性。 请参阅 使用 Lua 的项目列表。 在 developerWorks Linux 专区 可以找到为 Linux 开发人员准备的更多资源。 随时关注 developerWorks 技术事件和网络广播。 获得产品和技术 下载 Lua 5.0.2 或 Lua 5.1 源代码，从头开始编译 Lua。 在 Lua-users wiki 上，浏览很多预先构建的、可安装的 Lua 二进制文件。 在 LuaForge 上可以找到大量的代码库，包括很多语言绑定和专门的计算库。 订购免费的 SEK for Linux ，这有两张 DVD，包括最新的 IBM for Linux 试用软件，包括 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere®。 在您的下一个开发项目中采用 IBM 试用软件，这可以从 developerWorks 直接下载。 讨论 通过参与 developerWorks blogs 加入 developerWorks 社区。 关于作者 Martin Streicher 是 Linux Magazine 的首席编辑。他在普渡大学获得了计算机硕士学位，自 1982 年以来，就一直在使用 Pascal、C、Perl、Java 以及（最近使用的）Ruby 编程语言编写类 Unix 系统。

去年我作了一个Lua脚本的C++包装，有许多朋友感兴趣，并尝试使用，我感到受宠若惊。事实上，我作的包装，学习的目的比较强，它还是有许多缺陷的。为了让朋友们少走弯路，我推荐使用LuaPlus作为C++的包装。

LuaPlus是Lua的C++增强，也就是说，LuaPlus本身就是在Lua的源码上进行增强得来的。用它与C++进行合作，是比较好的一个选择。
LuaPlus目前版本为：LuaPlus for Lua 5.01 Distribution Build 1080 (February 28, 2004)。大家可以到http://luaplus.org/ 站点下载：
源码   (http://wwhiz.com/LuaPlus/LuaPlus50_Build1081.zip)
目标码 (http://wwhiz.com/LuaPlus/LuaPlus50_Build1081_Win32Binaries.zip)

我将在下面说明，如何使用LuaPlus，以及如何更方便的让LuaPlus与C++的类合作无间。

1. 调用Lua脚本

    // 创建Lua解释器：
    LuaStateOwner state;
   
    // 执行Lua脚本：
    state->DoString("print('Hello World\n')");
    // 载入Lua脚本文件并执行：
    state->DoFile("C:\\test.lua");
    // 载入编译后的Lua脚本文件并执行：
    state->DoFile("C:\\test.luac");

2. 与Lua脚本互相调用

    // 为Lua脚本设置变量
    state->GetGlobals().SetNumber("myvalue", 123456);
    // 获得Lua变量的值
    int myvalue = state->GetGlobal("myvalue").GetInteger();
   
    // 调用Lua函数
    LuaFunction<int> luaPrint = state->GetGlobal("print");
    luaPrint("Hello World\n");
   
    // 让Lua调用C语言函数
    int add(int a, int b){ return a+b;}
    state->GetGlobals().RegisterDirect("add", add);
    state->DoString("print(add(3,4))");
   
    // 让Lua调用C++类成员函数
    class Test{public: int add(int a, int b){return a+b;}};
    Test test;
    state->GetGlobals().RegisterDirect("add", test, add);
    state->DoString("print(add(3,4))");
   
3. 在Lua脚本中使用C++类
   
    这个稍微有点小麻烦。不过，我包装了一个LuaPlusHelper.h的文件，它可以很轻松的完成这个工作。它的实现也很简单，大家可以从源码上来获得如何用纯LuaPlus实现同样的功能。
    不过，这里仍然有一个限制没有解决：不能使用虚成员函数。不过考虑到我们仅是在Lua调用一下C++函数，并不是要将C++完美的导入到Lua，这个限制完全可以接受。
    另外，类成员变量不能直接在Lua中访问，可以通过类成员函数来访问（比如SetValue/GetValue之类)。

 // 下面是一个简单的C++类:   
 class Logger
 {
 public:
  void LOGMEMBER(const char* message)
  {
   printf("In member function: %s\n", message);
  }
 
  Logger()
  {
   printf("Constructing(%p)...\n", this);
   v = 10;
  }
  virtual ~Logger()
  {
   printf("Destructing(%p)...\n", this);
  }
 
  Logger(int n)
  {
   printf(" -- Constructing[%d](%p)...\n", n, this);
  }
  Logger(Logger* logger)
  {
   printf(" -- Constructing[%p](%p)...\n", logger, this);
   logger->LOGMEMBER(" Call From Constructor\n");
  }
  int SetValue(int val)
  {
   v = val;
  }
  int GetValue()
  {
   return v;
  }
 public:
  int v;
 };

    // 导入到Lua脚本：
    LuaClass<Logger>(state)
 .create("Logger") // 定义构造函数 Logger::Logger()
 .create<int>("Logger2")  // 定义构造函数 Logger::Logger(int)
 .create<Logger*>("Logger3") // 定义构造函数 Logger::Logger(Logger*)
 .destroy("Free")  // 定义析构函数 Logger::~Logger()
 .destroy("__gc")  // 定义析构函数 Logger::~Logger()
 .def("lm", &Logger::LOGMEMBER)  // 定义成员函数 Logger::LOGMEMBER(const char*)
 .def("SetValue", &Logger::SetValue)
 .def("GetValue", &Logger::GetValue);
 
    // 在Lua中使用Logger类(1)：
    state->DoString(
        "l = Logger();"  // 调用构造函数 Logger::Logger()
        "l.lm('Hello World 1');"  // 调用成员函数 Logger::LOGMEMBER(const char*)
        "l.Free();"  // 调用析构函数 Logger::~Logger()
        );

    // 在Lua中使用Logger类(2)：
    state->DoString(
        "m = Logger(10);" // 调用构造函数 Logger::Logger(int)
        "m.lm('Hello World 2');"  // 调用成员函数 Logger::LOGMEMBER(const char*)
        "n = Logger(m);" // 调用构造函数 Logger::Logger(Logger*)
        "n.lm('Hello World 3');"  // 调用成员函数 Logger::LOGMEMBER(const char*)
        "m.SetValue(11);"
        "print(m.GetValue());"
        "m,n = nil, nil;" // m,n 将由Lua的垃极回收来调用析构函数
        );

4. 将一组C函数归类到Lua模块

    //同上面一样，我采用LuaPlusHelper.h来简化：
    LuaModule(state, "mymodule")
 .def("add", add)
 .def("add2", test, add);
 
    state->DoString(
        "print(mymodule.add(3,4));"
        "print(mymodule.add2(3,4));"
        );

5. 使用Lua的Table数据类型
    // 在Lua中创建Table
    LuaObject table = state->GetGlobals().CreateTable("mytable");
    table.SetInteger("m", 10);
    table.SetNumber("f", 1.99);
    table.SetString("s", "Hello World");
    table.SetWString("ch", L"你好");
    table.SetString(1, "What");
   
    // 相当于Lua中的：
    // mytable = {m=10, f=1.99, s="Hello World", ch=L"你好", "What"}
   
    // 也可以使用table作为key和value:
    state->GetGlobals().CreateTable("nexttable")
        .SetString(table, "Hello")
        .SetObject("obj", table);
    // 相当于Lua中的：
    // nexttable = {mytable="Hello", obj=mytable}
   
    //获得Table的内容：
    LuaObject t2 = state->GetGlobals("mytable");
    int m = t2.GetByName("m").GetInteger();
   
    LuaObject t3 = state->GetGlobals("nexttable");
    std::string str = t3.GetByObject(t2).GetString();
   
6  遍历Table

 LuaStateOwner state;
 state.DoString( "MyTable = { Hi = 5, Hello = 10, Yo = 6 }" );
 
 LuaObject obj = state.GetGlobals()[ "MyTable" ];
 for ( LuaTableIterator it( obj ); it; it.Next() )
 {
     const char* key = it.GetKey().GetString();
     int num = it.GetValue().GetInteger();
 }

篇尾

上面我只是简单的举一些例子来说明LuaPlus以及LuaPlusHelper的使用方法，具体文档请参见LuaPlus。

需要下载LuaPlusHelper，请点这里：
http://www.d2-life.com/LBS/attachments/month_200509/06_zwo3LuaPlusHelper.zip

for k1,v1 inpairs(tbl)dofor k2,v2 inpairs(v1)do
...
end
end

dolocalpairs=pairs
for k1,v1 inpairs(tbl)dofor k2,v2 inpairs(v1)do
...
endend
end

function point (x,y)returnfunction()return x,y end
end
 
-- 使用范例
p=point(1,2)print(p())-- 输出 1	 2 
 

function point (x,y)returnfunction(idx)if idx=="x"thenreturn x
elseif idx=="y"thenreturn y
elsereturn x,y endend
end
 
-- 使用范例
p=point(1,2)print(p("x"))-- 1print(p("y"))-- 2 
 

function inherit(sub,super)setmetatable(sub,
{ __index=function(t,k)local ret=super[k]
sub[k]=ret
return ret
end})end

function foo(arg)
arg=arg or"default"
...
end

a=a ortrue-- 错误的写法，当 a 明确写为 false 的时候，也会被改变成 true 。
a= a ~= false-- 正确的写法，当 a 为 nil 的时候，被赋值为 true ；而 false 则不变。 
 

functionmax(a,b)return a>b and a or b
end

• OGRE libraries (OgreMain[_d].dll, OgrePlatform[_d].dll or libOgreMain.so, libOgrePlatform.so for linux).
• plugins.cfg - Text file specifying the rendering libraries available to Ogre (ie DX9, OpenGL).
• All the plugin libraries listed in plugins.cfg (you can remove items from plugins.cfg if you don't wish to use them).
• resources.cfg - If using the ExampleApplication, a text file specifing paths to materials, textures, models, etc.
• OgreCore.zip - Ensure resources.cfg has the proper path to this file if you plan to use the OGRE debug panel or profiler.
• Other Resources used in your program (*.zip; *.png; *.particle; *.mesh; ...).

还需要其他的第三方库：
These are required:

• Zlib: zlib1.dll; libz.so (debian: zlib1g, zlib1g-dev)
• DevIL: devil.dll, ilu.dll, ilut.dll; libIL.so, libILU.so (debian: libdevil1, libdevil-dev)

These are optional:

• CEGUI: OgreGUIRenderer[_d].dll, CEGUIBase[_d].dll, CEGUITaharezLook[_d].dll, CEGUIWindowsLook[_d].dll, xerces-c_2_5_0.dll
• CEGUI: libCEGUIBase.so, libCEGUIOgreRenderer.so, libxerces-c.so (debian: libcegui-mk2-0, libcegui-mk2-dev, libxerces26, libxerces26-dev)
• Cg: cg.dll; libCg.so (debian: nvidia-cg-toolkit)
• OpenEXR: openexr.dll??; (debian: libopenexr-dev libopenexr2 )
• ReferenceApp: ReferenceAppLayer.dll

不同的编译器还需要有：
Extras for Microsoft Visual C++ 6 (SP3+)

• stlport_vc6[_stldebug]46.dll
• msvcp60[D].dll
• msvcrt[D].dll

Extras for Microsoft Visual C++.Net 2002

• stlport_vc7[_stldebug]46.dll
• msvcp70[d].dll
• msvcr70[d].dll

Extras for Microsoft Visual C++.Net 2003

• msvcp71[d].dll
• msvcr71[d].dll

Extras for Mingw + STLPort

• libstlport[stlg].5.0.dll
• mingwm10.dll

设置环境变量：
If you downloaded and installed the precompiled OGRE SDK, you should already have an environment variable called 'OGRE_HOME' registered already, pointing at the folder where you installed. If it isn't there you probably installed under a different user, so define OGRE_HOME manually

If you downloaded the source distribution, you should register a new environment variable OGRE_SRC pointing at the 'ogrenew' folder from the OGRE source

Ogre源码项目的目录结构：
work_dir
    include
       *.h
    src
       *.cpp
    scripts
       *.vcproj

新建项目也依据这个结构，你的项目应该有这些文件夹：'bin', 'include', 'media', 'testsolution', 'scripts', and 'src'

修改新项目的属性：
Debugging : Working Directory                       = ..\bin\Debug
C/C++ : Preprocessor : Preprocessor Definitions += _STLP_DEBUG (only in Debug mode, not needed for .Net 2003 and 2005)
C/C++ : Code Generation : Use runtime library = Multithreaded Debug DLL (Multithreaded DLL in Release)
Linker : General : Output File                            = ..\bin\Debug\[appname].exe
Linker : Input : Additional Dependencies                += OgreMain_d.lib (OgreMain.lib in Release)

如果你是安装SDK:

C/C++ : General : Additional Include Directories 	 = ..\include;$(OGRE_HOME)\include;$(OGRE_HOME)\samples\include
Linker : General : Additional Library Directories         = $(OGRE_HOME)\lib

如果你是编译源码:

C/C++ : General : Additional Include Directories 	 = ..\include;$(OGRE_SRC)\OgreMain\include;$(OGRE_SRC)\Samples\Common\Include
Linker : General : Additional Library Directories         = $(OGRE_SRC)\OgreMain\Lib\Debug

这些设置好以后你就可以新建一个SampleApp.cpp文件，然后拷贝如下代码：

#include "ExampleApplication.h"

// Declare a subclass of the ExampleFrameListener class
class MyListener : public ExampleFrameListener
{
public:
    MyListener(RenderWindow* win, Camera* cam) : ExampleFrameListener(win, cam)
    {
    }

    bool frameStarted(const FrameEvent& evt)
    {
        return ExampleFrameListener::frameStarted(evt);        
    }

    bool frameEnded(const FrameEvent& evt)
    {
        return ExampleFrameListener::frameEnded(evt);        
    }
};

// Declare a subclass of the ExampleApplication class
class SampleApp : public ExampleApplication 
{
public:
   SampleApp() 
   {
   }

protected:
   // Define what is in the scene
   void createScene(void)
   {
       // put your scene creation in here
   }
  
   // Create new frame listener
   void createFrameListener(void)
   {
       mFrameListener = new MyListener(mWindow, mCamera);
       mRoot->addFrameListener(mFrameListener);
   }
};

#ifdef __cplusplus
extern "C" {
#endif

#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 
#define WIN32_LEAN_AND_MEAN 
#include "windows.h" 
INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT) 
#else 
int main(int argc, char **argv) 
#endif 
{
    // Instantiate our subclass
    SampleApp myApp;

    try {
        // ExampleApplication provides a go method, which starts the rendering.
        myApp.go();
    }
    catch (Ogre::Exception& e) {
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 
        MessageBoxA(NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
#else
        std::cerr << "Exception:\n";
        std::cerr << e.getFullDescription().c_str() << "\n";
#endif
        return 1;
    }

return 0;
}

#ifdef __cplusplus
}
#endif

未完！

C++资源之不完全导引（完整版）

来源：www.csdn.net

撰文：曾毅、陶文

声明：本文2004年5月首发于《CSDN开发高手》，版权归该杂志与《程序员》杂志社
所有。

------------------------------------------------------------------------
--------

　　1，前言

　　无数次听到“我要开始学习C++!”的呐喊，无数次听到“C++太复杂了，我真的
学不会”的无奈。Stan Lippman先生曾在《C++ Primer》一书中指出“C++是最为难
学的高级程序设计语言之一”，人们常将“之一”去掉以表达自己对C++的敬畏。诚
然，C++程序设计语言对于学习者的确有很多难以逾越的鸿沟，体系结构的庞大，应
接不暇并不断扩充的特性……除此之外，参考资料之多与冗杂使它的学习者望而却
步，欲求深入者苦不堪言。希望这一份不完全导引能够成为您C++学习之路上的引路
灯。

　　撰写本文的初衷并不打算带领大家体验古老的C++历史，如果你想了解C++的历
史与其前期发展中诸多技术的演变，你应当去参考Bjarne的《The Design and Evo
lution of C++》。当然也不打算给大家一个无所不包的宝典（并非不想：其一是因
水平有限，其二无奈C++之博大精深），所给出的仅仅是一些我们认为对于想学习C
++的广大读者来说最重要并且触手可及的开发与学习资源。

　　本文介绍并分析了一些编译器，开发环境，库，少量的书籍以及参考网站，并
且尽可能尝试着给出一个利用这些资源的导引，望对如同我们一样的初学者能够有
所裨益。

------------------------------------------------------------------------
--------

　　2，编译器

　　在C++之外的任何语言中，编译器都从来没有受到过如此之重视。因为C++是一
门相当复杂的语言，所以编译器也难于构建。直到最近我们才开始能够使用上完全
符合C++标准的编译器（哦，你可能会责怪那些编译器厂商不能尽早的提供符合标准
的编译器，这只能怪他们各自维系着自身的一套别人不愿接受的标准）。什么？你
说这无关紧要？哦，不，你所需要的是和标准化C++高度兼容的编译环境。长远来看
，只有这样的编译器对C++开发人员来说才是最有意义的工具，尤其是对于程序设计
语言的学习者。一至性让代码具备可移植性，并让一门语言及其库的应用更为广泛
。嗯，是的，我们这里只打算介绍一些公认的优秀编译器。

　　2.1 Borland C++

　　这个是Borland C++ Builder和Borland C++ Builder X这两种开发环境的后台
编译器。（哦，我之所以将之分为两种开发环境你应当能明白为什么，正如Delphi
7到Delphi8的转变，是革命性的两代。）Borland C++由老牌开发工具厂商Borland
倾力打造。该公司的编译器素以速度快，空间效率高著称，Borland C++ 系列编译
器秉承了这个传统，属于非常优质的编译器。标准化方面早在5.5版本的编译器中对
标准化C++的兼容就达到了92.73%。目前最新版本是Borland C++ Builder X中的6.
0版本，官方称100%符合ANSI/ISO的C++标准以及C99标准。嗯…这正是我前面所指的
“完全符合C++标准的编译器”。

　　2.2 Visual C++

　　这个正是我们熟知的Visual Studio 和 Visual Studio.net 2002, 2003以及2
005 Whidbey中带的C++编译器。由Microsoft公司研制。在Visual Studio 6.0中，
因为编译器有太多地方不能与后来出现的C++标准相吻合而饱受批评（想想你在使用
STL的时候编译时报出的那些令人厌恶的error和warning吧）。VC++6.0对标准化C+
+的兼容只有83.43%。但是随着C++编译器设计大师Stanley Lippman以及诸多C++社
群达人的加盟，在Visual Studio.NET 2003中，Visual C++编译器已经成为一个非
常成熟可靠的C++编译器了。Dr.Dobb's Journal的评测显示Visual C++7.1对标准C
++的兼容性高达98.22%，一度成为CBX之前兼容性最好的编译器。结合强大的Visua
l Studio.NET开发环境，是一个非常不错的选择。至于Whidbey时代的Visual C++,
似乎微软所最关注的是C++/CLI……我们不想评论微软下一代的C++编译器对标准化
兼容如何，但他确实越来越适合.NET (其实你和我的感觉可能是一样的，微软不应
当把标准C++这块肥肉丢给Borland,然而微软可能并不这样认为)。

　　2.3 GNU C++

　　著名的开源C++编译器。是类Unix操作系统下编写C++程序的首选。特点是有非
常好的移植性，你可以在非常广泛的平台上使用它，同时也是编写跨平台，嵌入式
程序很好的选择。另外在符合标准这个方面一直都非常好，GCC3.3大概能够达到96
.15%。但是由于其跨平台的特性，在代码尺寸速度等优化上略微差一点。

　　基于GNU C++的编译器有很多，比如：

　　(1) Mingw

　　http://www.mingw.org/

　　GCC的一个Windows的移植版本（Dev-C++的后台）

　　(2) Cygwin

　　http://sources.redhat.com/cygwin/

　　GCC的另外一个Windows移植版本是Cygwin的一部分，Cygwin是Windows下的一个
Unix仿真环境。严格的说是模拟GNU的环境，这也就是"Gnu's Not Unix"要表达的意
思，噢，扯远了，这并不是我们在这里关心的实质内容。

　　(3) Djgpp

　　http://www.delorie.com/djgpp/

　　这是GCC的DOS移植版本。

　　(4) RSXNT

　　http://www.mathematik.uni-bielefeld.de/~rainer/

　　这是GCC的DOS和Windows移植版本。

　　(5) Intel C++

　　著名CPU制造厂商Intel出品的编译器，Special Design for Intel x86！对于
Intel x86结构的CPU经过特别的优化。在有些应用情况下，特别是数值计算等高性
能应用，仅仅采用Intel的编译器编译就能大幅度的提高性能。

　　(6) Digital Mars C++

　　网络上提供免费下载，Zortech/Symantec C++的继承者，其前身在当年惨烈的
C++四国战中也是主角之一。

------------------------------------------------------------------------
--------

　　3，开发环境

　　开发环境对于程序员的作用不言而喻。选择自己朝夕相处的环境也不是容易的
事情，特别是在IDE如此丰富的情况下。下面就是我们推荐的一些常见的C++开发环
境，并没有包括一些小型的，罕见的IDE。其中任何一款都是功能丰富，可以用作日
常开发使用的。对于不同层面的开发者，请参见内文关于适用对象的描述。

　　3.1 Visual Studio 6.0

　　这个虽然是Microsoft公司的老版本的开发环境，但是鉴于其后继版本Visual
Studio.NET的庞大身躯，以及初学者并不那么高的功能要求，所以推荐这个开发环
境给C++的初学者，供其学习C++的最基本的部分，比如C的那部分子集，当然你别指
望他能够支持最新的C99标准。在日常的开发中，仍然有很多公司使用这个经典稳定
的环境，比如笔者就看曾亲见有些公司将其编译器替换为GCC做手机开发之用。

　　3.2 Visual Studio.NET 2003

　　作为Microsoft公司官方正式发布的最新版本开发环境，其中有太多激动人心的
功能。结合其最新的C++编译器。对于机器配置比较好的开发人员来说，使用这个开
发环境将能满足其大部分的要求。这里不打算单独说Visual Studio Whidbey,虽然
Visual Studio .NET 2005 - Whidbey社区预览版已经推出，但暂不是很稳定，读者
可以亲身去体验。

　　3.3 Borland C++ Builder 6

　　这个并不是Borland的C++开发环境的最新版本。选择它的原因是它不是用Java
写的IDE，速度比较快。它有一个很完善的GUI窗体设计器，和Delphi共用一个VCL。
由于这些特点，比较适合初学者上手。但是由于其GUI的中心位置，可能不利于对于
C++语言的学习。而且其为了支持VCL这个Object Pascal写的库也对C++进行了一些
私有的扩充。使得人们有一个不得不接受的事实：“Borland C++ Builder 6的高手
几乎都是Delphi高手”。

　　3.4 Borland C++ Builder X

　　正如前文所述，虽然版本号上和前面那个IDE非常相象，但是其实它们是完全不
同的两个集成开发环境。C++Builder更多的是一个和Delphi同步的C++版本的开发环
境，C++BuilderX则是完全从C++的角度思考得出的一个功能丰富的IDE。其最大的特
点是跨平台，跨编译器，多种Framework的集成，并且有一个WxWindows为基础的GU
I设计器。尤其是采用了纯C++来重写了整个Framework,摒弃了以前令人无奈的版本
。对于C++的开发来说，从编译器，到库，到功能集成都是非常理想的。可以预见，
Borland C++ Builder X 2.0很值得C++爱好者期待。唯一令人难堪之处是作为一个
C++的开发工具，其IDE是用Java写的，在配置不够理想的机器上请慎重考虑再安装
。

　　3.5 Emacs + GCC

　　前面讲的大部分是Windows环境下的集成开发环境。Linux上的开发者更倾向于
使用Emacs来编辑C++的文件，用Makefile来命令GCC做编译。虽然看上去比较松散，
但是这些东西综合起来还是一个开0发环境。如果你能够娴熟的使用这样的环境写程
序，你的水平应该足够指导我们来写这篇陋文了。

　　3.6 Dev C++

　　GCC是一个很好的编译器。在Windows上的C++编译器一直和标准有着一段距离的
时候，GCC就是一个让Windows下开发者流口水的编译器。Dev-C++就是能够让GCC跑
在Windows下的工具，作为集成开发环境，还提供了同专业IDE相媲美的语法高亮，
代码提示，调试等功能。由于使用Delphi开发，占用内存少，速度很快，比较适合
轻量级的学习和使用。

　　3.7 Eclipse + CDT

　　Eclipse可是近来大名鼎鼎的开发工具。最新一期的Jolt大奖就颁给了这个杰出
的神物。说其神奇是因为，它本身是用Java写的，但是拥有比一般Java写的程序快
得多的速度。而且因为其基于插件组装一切的原则，使得能够有CDT这样的插件把E
clipse变成一个C/C++的开发环境。如果你一直用Eclipse写Java的程序，不妨用它
体验一下C++开发的乐趣。

------------------------------------------------------------------------
--------

　　4，工具

　　C++的辅助工具繁多，我们分门别类的为大家作介绍：

　　4.1 文档类

　　(1) Doxygen

　　参考站点：http://www.doxygen.org

　　Doxygen是一种适合C风格语言（如C++、C、IDL、Java甚至包括C#和PHP）的、
开放源码的、基于命令行的文档产生器。

　　(2) C++2HTML

　　参考站点：http://www.bedaux.net/cpp2html/

　　把C++代码变成语法高亮的HTML

　　(3) CodeColorizer

　　参考站点：http://www.chami.com/colorizer/

　　它能把好几种语言的源代码着色为HTML

　　(4) Doc-O-Matic

　　参考站点：http://www.doc-o-matic.com/

　　Doc-O_Matic为你的C/C++，C++.net，Delphi/Pascal, VB.NET，C#和Java程序
或者组件产生准确的文档。Doc-O-Matic使用源代码中的符号和注释以及外部的文档
文件创建与流行的文档样式一致的文档。

　　(5) DocVizor

　　参考站点：http://www.ucancode.net/Products/DocBuilder/Features.htm

　　DocVizor满足了面向对象软件开发者的基本要求——它让我们能够看到C++工程
中的类层次结构。DocVizor快速地产生完整可供打印的类层次结构图，包括从第三
方库中来的那些类，除此之外DocVizor还能从类信息中产生HTML文件。

　　(6) SourcePublisher C++

　　参考站点：http://www.scitools.com/sourcepublisher_c.html

　　给源代码产生提供快速直观的HTML报表，包括代码，类层次结构，调用和被调
用树，包含和被包含树。支持多种操作系统。

　　(7) Understand

　　参考站点：http://www.scitools.com/ucpp.html

　　分析任何规模的C或者C++工程，帮助我们更好的理解以及编写文档。

　　4.2 代码类

　　(1) CC-Rider

　　参考站点：http://www.cc-rider.com

　　CC-Rider是用于C/C++程序强大的代码可视化工具，通过交互式浏览、编辑及自
动文件来促进程序的维持和发展。

　　(2) CodeInspect

　　参考站点：http://www.yokasoft.com/

　　一种新的C/C++代码分析工具。它检查我们的源代码找出非标准的，可能的，以
及普通的错误代码。

　　(3) CodeWizard

　　参考站点：http://www.parasoft.com

　　先进的C/C++源代码分析工具，使用超过500个编码规范自动化地标明危险的，
但是编译器不能检查到的代码结构。

　　(4) C++ Validation Test Suites

　　参考站点：http://www.plumhall.com/suites.html

　　一组用于测试编译器和库对于标准吻合程度的代码库。

　　(5) CppRefactory

　　参考站点：http://cpptool.sourceforge.net/

　　CPPRefactory是一个使得开发者能够重构他们的C++代码的程序。目的是使得C
++代码的重构能够尽可能的有效率和简单。

　　(6) Lzz

　　参考站点：http://www.lazycplusplus.com/

　　Lzz是一个自动化许多C++编程中的体力活的工具。它能够节省我们许多事件并
且使得编码更加有乐趣。给出一系列的声明，Lzz会给我们创建头文件和源文件。

　　(7) QA C++ Generation 2000

　　参考站点：http://www.programmingresearch.com/solutions/qacpp.htm

　　它关注面向对象的C++源代码，对有关于设计，效率，可靠性，可维护性的部分
提出警告信息。

　　(8) s-mail project - Java to C++DOL

　　参考站点：http://sadlocha.strefa.pl/s-mail/ja2dol.html

　　把Java源代码翻译为相应的C++源代码的命令行工具。

　　(9) SNIP from Cleanscape Software International

　　参考站点：http://www.cleanscape.net/stdprod/snip/index.html

　　一个填平编码和设计之间沟壑的易于使用的C++开发工具，节省大量编辑和调试
的事件，它还使得开发者能够指定设计模式作为对象模型，自动从对象模型中产生
C++的类。

　　(10) SourceStyler C++

　　参考站点：http://www.ochresoftware.com/

　　对C/C++源代码提供完整的格式化和排版控制的工具。提供多于75个的格式化选
项以及完全支持ANSI C++。

　　4.3 编译类

　　(1) Compilercache

　　参考站点：http://www.erikyyy.de/compilercache/

　　Compilercache是一个对你的C和C++编译器的封装脚本。每次我们进行编译，封
装脚本，把编译的结果放入缓存，一旦编译相同的东西，结果将从缓存中取出而不
是再次编译。

　　(2) Ccache

　　参考站点：http://ccache.samba.org/

　　Ccache是一个编译器缓存。它使用起来就像C/C++编译器的缓存预处理器，编译
速度通常能提高普通编译过程的5~10倍。

　　(3) Cmm (C++ with MultiMethods)

　　参考站点：http://www.op59.net/cmm/cmm-0.28/users.html

　　这是一种C++语言的扩展。读入Cmm源代码输出C++的源代码，功能是对C++语言
添加了对multimethod的支持。

　　(4) The Frost Project

　　参考站点：http://frost.flewid.de/

　　Forst使得你能够在C++程序中像原生的C++特性一样使用multimethod以及虚函
数参数。它是一个编译器的外壳。

　　4.4 测试和调试类

　　(1) CPPUnit

　　CppUnit 是个基于 LGPL 的开源项目，最初版本移植自 JUnit，是一个非常优
秀的开源测试框架。CppUnit 和 JUnit 一样主要思想来源于极限编程。主要功能就
是对单元测试进行管理，并可进行自动化测试。

　　(2) C++Test

　　参考站点：http://www.parasoft.com/

　　C++ Test是一个单元测试工具，它自动化了C和C++类，函数或者组件的测试。

　　(3) Cantata++

　　参考站点：http://www.iplbath.com/products/tools/pt400.shtml

　　设计的目的是为了满足在合理的经济开销下使用这个工具可以让开发工程师开
展单元测试和集成测试的需求.

　　(4) Purify

　　参考站点：http://www-900.ibm.com/cn/software/rational/products/purif
yplus/index.shtml

　　IBM Rational PurifyPlus是一套完整的运行时分析工具，旨在提高应用程序的
可靠性和性能。PurifyPlus将内存错误和泄漏检测、应用程序性能描述、代码覆盖
分析等功能组合在一个单一、完整的工具包中。

　　(5) BoundsChecker

　　BoundsChecker是一个C++运行时错误检测和调试工具。它通过在Visual Studi
o内自动化调试过程加速开发并且缩短上市的周期。BoundsChecker提供清楚，详细
的程序错误分析，许多是对C++独有的并且在static，stack和heap内存中检测和诊
断错误，以及发现内存和资源的泄漏。　　(6) Insure++

　　参考站点：http://www.parasoft.com/

　　一个自动化的运行时程序测试工具，检查难以察觉的错误,如内存覆盖，内存泄
漏，内存分配错误，变量初始化错误，变量定义冲突，指针错误，库错误，逻辑错
误和算法错误等。

　　(7) GlowCode

　　参考站点：http://www.glowcode.com/

　　GlowCode包括内存泄漏检查，code profiler，函数调用跟踪等功能。给C++开
发者提供完整的错误诊断，和运行时性能分析工具包。

　　(8) Stack Spy

　　参考站点：http://www.imperioustech.com/

　　它能捕捉stack corruption, stack over run, stack overflow等有关栈的错
误。

------------------------------------------------------------------------
--------

　　5，库

　　在C++中，库的地位是非常高的。C++之父 Bjarne Stroustrup先生多次表示了
设计库来扩充功能要好过设计更多的语法的言论。现实中，C++的库门类繁多，解决
的问题也是极其广泛，库从轻量级到重量级的都有。不少都是让人眼界大开，亦或
是望而生叹的思维杰作。由于库的数量非常庞大，而且限于笔者水平，其中很多并
不了解。所以文中所提的一些库都是比较著名的大型库。

　　5.1 标准库

　　标准库中提供了C++程序的基本设施。虽然C++标准库随着C++标准折腾了许多年
，直到标准的出台才正式定型，但是在标准库的实现上却很令人欣慰得看到多种实
现，并且已被实践证明为有工业级别强度的佳作。

　　(1) Dinkumware C++ Library

　　参考站点：http://www.dinkumware.com/

　　P.J. Plauger编写的高品质的标准库。P.J. Plauger博士是Dr. Dobb's程序设
计杰出奖的获得者。其编写的库长期被Microsoft采用，并且最近Borland也取得了
其OEM的license，在其C/C++的产品中采用Dinkumware的库。

　　(2) RogueWave Standard C++ Library

　　参考站点：http://www.roguewave.com/

　　这个库在Borland C++ Builder的早期版本中曾经被采用，后来被其他的库给替
换了。笔者不推荐使用。

　　(3) SGI STL

　　参考站点：http://www.roguewave.com/

　　SGI公司的C++标准模版库。

　　(4) STLport

　　参考站点：http://www.stlport.org/

　　SGI STL库的跨平台可移植版本。

　　5.2 “准”标准库 - Boost

　　参考站点：http://www.boost.org

　　国内镜像：http://www.c-view.org/tech/lib/boost/index.htm

　　Boost库是一个经过千锤百炼、可移植、提供源代码的C++库，作为标准库的后
备，是C++标准化进程的发动机之一。 Boost库由C++标准委员会库工作组成员发起
，在C++社区中影响甚大，其成员已近2000人。 Boost库为我们带来了最新、最酷、
最实用的技术，是不折不扣的“准”标准库。

　　Boost中比较有名气的有这么几个库：

　　Regex

　　正则表达式库

　　Spirit

　　LL parser framework，用C++代码直接表达EBNF

　　Graph

　　图组件和算法

　　Lambda

　　在调用的地方定义短小匿名的函数对象，很实用的functional功能

　　concept check

　　检查泛型编程中的concept

　　Mpl

　　用模板实现的元编程框架

　　Thread

　　可移植的C++多线程库

　　Python

　　把C++类和函数映射到Python之中

　　Pool

　　内存池管理

　　smart_ptr

　　5个智能指针，学习智能指针必读，一份不错的参考是来自CUJ的文章：

　　Smart Pointers in Boost，哦，这篇文章可以查到，CUJ是提供在线浏览的。
中文版见笔者在《Dr. Dobb's Journal软件研发杂志》第7辑上的译文。

　　Boost总体来说是实用价值很高，质量很高的库。并且由于其对跨平台的强调，
对标准C++的强调，是编写平台无关，现代C++的开发者必备的工具。但是Boost中也
有很多是实验性质的东西，在实际的开发中实用需要谨慎。并且很多Boost中的库功
能堪称对语言功能的扩展，其构造用尽精巧的手法，不要贸然的花费时间研读。Bo
ost另外一面，比如Graph这样的库则是具有工业强度，结构良好，非常值得研读的
精品代码，并且也可以放心的在产品代码中多多利用。

　　5.3 GUI

　　在众多C++的库中，GUI部分的库算是比较繁荣，也比较引人注目的。在实际开
发中，GUI库的选择也是非常重要的一件事情，下面我们综述一下可选择的GUI库，
各自的特点以及相关工具的支持。

　　(1) MFC

　　大名鼎鼎的微软基础类库（Microsoft Foundation Class）。大凡学过VC++的
人都应该知道这个库。虽然从技术角度讲，MFC是不大漂亮的，但是它构建于Windo
ws API 之上，能够使程序员的工作更容易,编程效率高，减少了大量在建立 Windo
ws 程序时必须编写的代码，同时它还提供了所有一般 C++ 编程的优点，例如继承
和封装。MFC 编写的程序在各个版本的Windows操作系统上是可移植的，例如，在
Windows 3.1下编写的代码可以很容易地移植到 Windows NT 或 Windows 95 上。但
是在最近发展以及官方支持上日渐势微。

　　(2) QT

　　参考网站：http://www.trolltech.com/

　　Qt是Trolltech公司的一个多平台的C++图形用户界面应用程序框架。它提供给
应用程序开发者建立艺术级的图形用户界面所需的所用功能。Qt是完全面向对象的
很容易扩展，并且允许真正地组件编程。自从1996年早些时候，Qt进入商业领域，
它已经成为全世界范围内数千种成功的应用程序的基础。Qt也是流行的Linux桌面环
境KDE 的基础，同时它还支持Windows、Macintosh、Unix/X11等多种平台。

　　(3) WxWindows

　　参考网站：http://www.wxwindows.org/

　　跨平台的GUI库。因为其类层次极像MFC，所以有文章介绍从MFC到WxWindows的
代码移植以实现跨平台的功能。通过多年的开发也是一个日趋完善的GUI库，支持同
样不弱于前面两个库。并且是完全开放源代码的。新近的C++ Builder X的GUI设计
器就是基于这个库的。

　　(4) Fox

　　参考网站：http://www.fox-toolkit.org/

　　开放源代码的GUI库。作者从自己亲身的开发经验中得出了一个理想的GUI库应
该是什么样子的感受出发，从而开始了对这个库的开发。有兴趣的可以尝试一下。

　　(5) WTL

　　基于ATL的一个库。因为使用了大量ATL的轻量级手法，模板等技术，在代码尺
寸，以及速度优化方面做得非常到位。主要面向的使用群体是开发COM轻量级供网络
下载的可视化控件的开发者。

　　(6) GTK

　　参考网站：http://gtkmm.sourceforge.net/

　　GTK是一个大名鼎鼎的C的开源GUI库。在Linux世界中有Gnome这样的杀手应用。
而GTK就是这个库的C++封装版本。

　　5.4 网络通信

　　(1) ACE

　　参考网站：http://www.cs.wustl.edu/~schmidt/ACE.html

　　C++库的代表，超重量级的网络通信开发框架。ACE自适配通信环境（Adaptive
 Communication Environment）是可以自由使用、开放源代码的面向对象框架，在
其中实现了许多用于并发通信软件的核心模式。ACE提供了一组丰富的可复用C++包
装外观（Wrapper Facade）和框架组件，可跨越多种平台完成通用的通信软件任务
，其中包括：事件多路分离和事件处理器分派、信号处理、服务初始化、进程间通
信、共享内存管理、消息路由、分布式服务动态（重）配置、并发执行和同步，等
等。

　　(2) StreamModule

　　参考网站：http://www.omnifarious.org/StrMod/

　　设计用于简化编写分布式程序的库。尝试着使得编写处理异步行为的程序更容
易，而不是用同步的外壳包起异步的本质。

　　(3) SimpleSocket

　　参考网站：http://home.hetnet.nl/~lcbokkers/simsock.htm

　　这个类库让编写基于socket的客户/服务器程序更加容易。

　　(4) A Stream Socket API for C++

　　参考网站：http://www.pcs.cnu.edu/~dgame/sockets/socketsC++/sockets.h
tml

　　又一个对Socket的封装库。

　　5.5 XML

　　(1) Xerces

　　参考网站：http://xml.apache.org/xerces-c/

　　Xerces-C++ 是一个非常健壮的XML解析器，它提供了验证，以及SAX和DOM API
。XML验证在文档类型定义(Document Type Definition，DTD)方面有很好的支持，
并且在2001年12月增加了支持W3C XML Schema 的基本完整的开放标准。

　　(2) XMLBooster

　　参考网站：http://www.xmlbooster.com/

　　这个库通过产生特制的parser的办法极大的提高了XML解析的速度，并且能够产
生相应的GUI程序来修改这个parser。在DOM和SAX两大主流XML解析办法之外提供了
另外一个可行的解决方案。

　　(3) Pull Parser

　　参考网站：http://www.extreme.indiana.edu/xgws/xsoap/xpp/

　　这个库采用pull方法的parser。在每个SAX的parser底层都有一个pull的parse
r，这个xpp把这层暴露出来直接给大家使用。在要充分考虑速度的时候值得尝试。

　　(4) Xalan

　　参考网站：http://xml.apache.org/xalan-c/

　　Xalan是一个用于把XML文档转换为HTML，纯文本或者其他XML类型文档的XSLT处
理器。

　　(5) CMarkup

　　参考网站：http://www.firstobject.com/xml.htm

　　这是一种使用EDOM的XML解析器。在很多思路上面非常灵活实用。值得大家在D
OM和SAX之外寻求一点灵感。

　　(6) libxml++

　　http://libxmlplusplus.sourceforge.net/

　　libxml++是对著名的libxml XML解析器的C++封装版本

　　5.6 科学计算

　　(1) Blitz++

　　参考网站：http://www.oonumerics.org/blitz/

　　Blitz++ 是一个高效率的数值计算函数库，它的设计目的是希望建立一套既具
像C++ 一样方便，同时又比Fortran速度更快的数值计算环境。通常，用C++所写出
的数值程序，比 Fortran慢20%左右，因此Blitz++正是要改掉这个缺点。方法是利
用C++的template技术，程序执行甚至可以比Fortran更快。Blitz++目前仍在发展中
，对于常见的SVD，FFTs，QMRES等常见的线性代数方法并不提供，不过使用者可以
很容易地利用Blitz++所提供的函数来构建。

　　(2) POOMA

　　参考网站：http://www.codesourcery.com/pooma/pooma

　　POOMA是一个免费的高性能的C++库，用于处理并行式科学计算。POOMA的面向对
象设计方便了快速的程序开发，对并行机器进行了优化以达到最高的效率，方便在
工业和研究环境中使用。

　　(3) MTL

　　参考网站：http://www.osl.iu.edu/research/mtl/

　　Matrix Template Library(MTL)是一个高性能的泛型组件库，提供了各种格式
矩阵的大量线性代数方面的功能。在某些应用使用高性能编译器的情况下，比如In
tel的编译器，从产生的汇编代码可以看出其与手写几乎没有两样的效能。

　　(4) CGAL

　　参考网站：www.cgal.org

　　Computational Geometry Algorithms Library的目的是把在计算几何方面的大
部分重要的解决方案和方法以C++库的形式提供给工业和学术界的用户。

　　5.7 游戏开发

　　(1) Audio/Video 3D C++ Programming Library

　　参考网站：http://www.galacticasoftware.com/products/av/

　　***3D是一个跨平台，高性能的C++库。主要的特性是提供3D图形，声效支持（S
B,以及S3M），控制接口（键盘，鼠标和遥感），XMS。

　　(2) KlayGE

　　参考网站：http://home.g365.net/enginedev/

　　国内游戏开发高手自己用C++开发的游戏引擎。KlayGE是一个开放源代码、跨平
台的游戏引擎，并使用Python作脚本语言。KlayGE在LGPL协议下发行。感谢龚敏敏
先生为中国游戏开发事业所做出的贡献。

　　(3) OGRE

　　参考网站：http://www.ogre3d.org

　　OGRE（面向对象的图形渲染引擎）是用C++开发的，使用灵活的面向对象3D引擎
。它的目的是让开发者能更方便和直接地开发基于3D硬件设备的应用程序或游戏。
引擎中的类库对更底层的系统库（如：Direct3D和OpenGL）的全部使用细节进行了
抽象，并提供了基于现实世界对象的接口和其它类。

　　5.8 线程

　　(1) C++ Threads

　　参考网站：http://threads.sourceforge.net/

　　这个库的目标是给程序员提供易于使用的类，这些类被继承以提供在Linux环境
中很难看到的大量的线程方面的功能。

　　(2) ZThreads

　　参考网站：http://zthread.sourceforge.net/

　　一个先进的面向对象，跨平台的C++线程和同步库。

　　5.9 序列化

　　(1) s11n

　　参考网站：http://s11n.net/

　　一个基于STL的C++库，用于序列化POD，STL容器以及用户定义的类型。

　　(2) Simple XML Persistence Library

　　参考网站：http://sxp.sourceforge.net/

　　这是一个把对象序列化为XML的轻量级的C++库。

　　5.10 字符串

　　(1) C++ Str Library

　　参考网站：http://www.utilitycode.com/str/

　　操作字符串和字符的库，支持Windows和支持gcc的多种平台。提供高度优化的
代码，并且支持多线程环境和Unicode，同时还有正则表达式的支持。

　　(2) Common Text Transformation Library

　　参考网站：http://cttl.sourceforge.net/

　　这是一个解析和修改STL字符串的库。CTTL substring类可以用来比较，插入，
替换以及用EBNF的语法进行解析。

　　(3) GRETA

　　参考网站：http://research.microsoft.com/projects/greta/

　　这是由微软研究院的研究人员开发的处理正则表达式的库。在小型匹配的情况
下有非常优秀的表现。

　　5.11 综合

　　(1) P::Classes

　　参考网站：http://pclasses.com/

　　一个高度可移植的C++应用程序框架。当前关注类型和线程安全的signal/slot
机制，i/o系统包括基于插件的网络协议透明的i/o架构，基于插件的应用程序消息
日志框架，访问sql数据库的类等等。

　　(2) ACDK - Artefaktur Component Development Kit

　　参考网站：http://acdk.sourceforge.net/

　　这是一个平台无关的C++组件框架，类似于Java或者.NET中的框架（反射机制，
线程，Unicode，废料收集，I/O，网络，实用工具，XML，等等），以及对Java, P
erl, Python, TCL, Lisp, COM 和 CORBA的集成。

　　(3) dlib C++ library

　　参考网站：http://www.cis.ohio-state.edu/~kingd/dlib/

　　各种各样的类的一个综合。大整数，Socket，线程，GUI，容器类,以及浏览目
录的API等等。

　　(4) Chilkat C++ Libraries

　　参考网站：http://www.chilkatsoft.com/cpp_libraries.asp

　　这是提供zip，e-mail，编码，S/MIME，XML等方面的库。

　　(5) C++ Portable Types Library (PTypes)

　　参考网站：http://www.melikyan.com/ptypes/

　　这是STL的比较简单的替代品，以及可移植的多线程和网络库。

　　(6) LFC

　　参考网站：http://lfc.sourceforge.net/

　　哦，这又是一个尝试提供一切的C++库

　　5.12 其他库

　　(1) Loki

　　参考网站：http://www.moderncppdesign.com/

　　哦，你可能抱怨我早该和Boost一起介绍它，一个实验性质的库。作者在loki中
把C++模板的功能发挥到了极致。并且尝试把类似设计模式这样思想层面的东西通过
库来提供。同时还提供了智能指针这样比较实用的功能。

　　(2) ATL

　　ATL(Active Template Library)

　　是一组小巧、高效、灵活的类，这些类为创建可互操作的COM组件提供了基本的
设施。

　　(3) FC++: The Functional C++ Library

　　这个库提供了一些函数式语言中才有的要素。属于用库来扩充语言的一个代表
作。如果想要在OOP之外寻找另一分的乐趣，可以去看看函数式程序设计的世界。大
师Peter Norvig在 “Teach Yourself Programming in Ten Years”一文中就将函
数式语言列为至少应当学习的6类编程语言之一。

　　(4) FACT!

　　参考网站：http://www.kfa-juelich.de/zam/FACT/start/index.html

　　另外一个实现函数式语言特性的库

　　(5) Crypto++

　　提供处理密码，消息验证，单向hash，公匙加密系统等功能的免费库。

　　还有很多非常激动人心或者是极其实用的C++库，限于我们的水平以及文章的篇
幅不能包括进来。在对于这些已经包含近来的库的介绍中，由于并不是每一个我们
都使用过，所以难免有偏颇之处，请读者见谅。

------------------------------------------------------------------------
--------

　　6，书籍

　　以前熊节先生曾撰文评论相对于Java程序设计语言，C++的好书多如牛毛。荣耀
先生在《程序员》杂志上撰文《C++程序设计之四书五经》也将本领域内几乎所有的
经典书籍作了全面的介绍,任何关于书的评论此时看来便是很多余的了。个人浅见，
除非你打算以C++作为唯一兴趣或者生存之本，一般读者确实没有足够的时间和必要
将20余本书籍全部阅读。更有参考价值的是荣耀先生的另一篇文章：《至少应该阅
读的九本C++著作》，可以从下面的地址浏览到此文：

　　http://www.royaloo.com/articles/articles_2003/9CppBooks.htm

　　下面几本书对于走在C++初学之路上的读者是我们最愿意推荐给大家的：

　　(1) 《C++ Primer》

　　哦，也许你会抱怨我们为什么不先介绍TCPL,但对于走在学习之路上的入门者，
本书内容更为全面，更为详细易懂，我们称它为“C++的超级宝典”并不过分。配有
一本不错的习题解答《C++ Primer Answer Book》可以辅助你的学习之路。

　　(2) 《Essential C++》

　　如果说《C++ Primer》是C++领域的超级宝典，那么此书作为掌握C++的大局观
当之无愧。正如《.NET大局观》一书能够让读者全揽.NET，本书讲述了C++中最核心
的全部主题。书虽不厚，内容精炼，不失为《C++ Primer》读者茶余饭后的主题回
顾之作。

　　(3) 《The C++ Programming Language》

　　Bjarne为你带来的C++教程，真正能够告诉你怎么用才叫真正的C++的唯一一本
书。虽然如同“某某程序设计语言”这样的书籍会给大家一个内容全揽，入门到精
通的感觉，但本书确实不太适合初学者阅读。如果你自认为是一名很有经验的C++程
序员，那至少也要反复咀嚼Bjarne先生所强调的若干内容。

　　(4) 《Effective C++》，《More Effective C++》

　　是的，正如一些C++爱好者经常以读过与没有读过上述两本作品来区分你是否是
C++高手。我们也极力推崇这两本著作。在各种介绍C++专家经验的书籍里面，这两
本是最贴近语言本质，看后最能够有脱胎换骨感觉的书，读此书你需每日三省汝身
。

　　技术书籍仁者见仁，过多的评论反无太多意义，由读者喜好选择最适合自己的
书方为上策。

------------------------------------------------------------------------
--------

　　7，资源网站

　　正如我们可以通过计算机历史上的重要人物了解计算机史的发展，C++相关人物
的网站也可以使我们得到最有价值的参考与借鉴，下面的人物我们认为没有介绍的
必要，只因下面的人物在C++领域的地位众所周知，我们只将相关的资源进行罗列以
供读者学习，他们有的工作于贝尔实验室，有的工作于知名编译器厂商，有的在不
断推进语言的标准化，有的为读者撰写了多部千古奇作……
　　(1) Bjarne Stroustrup
　　http://www.research.att.com/~bs/

　　(2) Stanley B. Lippman
　　http://blogs.msdn.com/slippman/
　　中文版 http://www.zengyihome.net/slippman/index.htm

　　(3) Scott Meyers
　　http://www.aristeia.com/

　　(4) David Musser
　　http://www.cs.rpi.edu/~musser/

　　(5) Bruce Eckel
　　http://www.bruceeckel.com

　　(6) Nicolai M. Josuttis
　　http://www.josuttis.com/

　　(7) Herb Sutter
　　http://www.gotw.ca/

　　(8) Andrei Alexandrescu
　　http://www.coderncppdesign.com/

　　(9) 侯捷先生
　　http://www.jjhou.com

　　(10) 孟岩先生
　　先生繁忙于工作，痴迷于技术，暂无个人主页，关于先生的作品可以通过CSDN
的专栏和侯先生的主页访问到。

　　(11) 荣耀先生
　　http://www.royaloo.com/

　　(12) 潘爱民先生
　　http://www.icst.pku.edu.cn/panaimin/pam_homepage.htm

　　除了上述大师的主页外，以下的综合类C++学习参考站点是我们非常愿意向大家
推荐的：

　　(1) CodeProject
　　http://www.codeproject.com

　　(2) CodeGuru
　　http://www.codeguru.com

　　(3) Dr. Dobb's Journal
　　http://www.ddj.com

　　(4) C/C++ Users Journal
　　http://www.cuj.com

　　(5) C维视点
　　http://www.c-view.org

　　(6) allaboutprogram
　　http://www.allaboutprogram.com
　　其他资料

　　(1) ISO IEC JTC1/SC22/WG21 - C++：标准C++的权威参考
　　http://anubis.dkuug.dk/jtc1/sc22/wg21/

　　(2) C++ FAQ LITE — Frequently Asked Questions: 最为全面的C++FAQ
　　http://www.sunistudio.com/cppfaq/index.html
　　C/C++ 新闻组：
　　你不妨尝试从这里提问和回答问题，很多不错的Q&A资源......

　　(1) .alt.comp.lang.learn.c-c++
　　这个简单些，如果你和我一样是个菜鸟

　　(2) .comp.lang.c++.moderated
    嗯，这个显然水平高一些

　　(3) .comp.std.c++
　　如果你需要讨论标准C++相关话题的话

------------------------------------------------------------------------
--------

　　8，不得不写的结束语

　　结束的时候也是总结现状，展望未来的时候。虽然C++从脱胎于C开始，一路艰
难坎坷的走过来，但是无论如何C++已经取得了工业基础的地位。文章列举的大量相关
资源就是最好的证明，而业界的大量用C++写成的产品代码以及大量的C++职业工程
师则是最直接的证明。同时，我们可以看到各个高校的计算机专业都开设有C++这门
课程，网络上对于C++的学习讨论也从来都没有停过。但是，在Java和.NET两大企业
开发平台的围攻下，给人的感觉是C++越来越“不行”了。

　　C++在面向企业的软件开发中，在开发便捷性等方面的确要比Java和C#差很多，
其中一个问题是C++语言本身比较复杂，学习曲线比较陡峭，另外一个问题是C++标
准化的时间太长，丧失了很多的壮大机会，耗费了很多精力在厂商的之间的斗争上
，而C++的标准库离一个完善的程序开发框架还缺少太多太多的内容，各个第三方的
类库和框架又在一致性和完整性上没法和随平台提供的框架相提并论。难道C++真的
要退出历史舞台了？

　　从C++目前的活跃程度，以及应用现状来说是完全能够肯定C++仍然是软件工业
的基础，也不会退出历史舞台的。另外从Boost，Loki这些库中我们也能够看到C++
的发展非常活跃，对于新技术新思维非常激进，C++仍然广泛受到关注。从ACE在高
性能通信领域的应用，以及MTL这样的库在数值计算领域的出色表现，我们可以看到
C++在高性能应用场合下的不可替代的作用，而嵌入式系统这样的内存受限开发平台
，比如Symbian OS上，C++已经发挥着并且将发挥更大的作用。可以预见的是以后的
软件无论上层的应用怎么变，它的底层核心都会是由C/C++这样的系统级软件编写的
，比如Java虚拟机，.NET Framwork。因为只有这样的系统级软件才能完全彻底的发
挥机器的功能。

　　需要看到的是两个趋势，一个趋势是C++变得更加复杂，更加学院派，通过模板
等有潜力的语法因素构造越来越精巧的库成为了现代C++的热点，虽然在利用库实现
新的编程范式，乃至设计模式等方面很有开创意义，也确实产生了一些能够便捷开
发的工具，但是更多的是把C++变得更加强大，更加复杂，也更加难懂，似乎也更加
学院派，不得不说它正在向边缘化道路发展。另一个趋势是C++在主流的企业应用开
发中已经逐渐退出了，ERP这样的企业软件开发中基本上不会考虑C++，除非需要考
虑性能或者和遗留代码的集成这些因素。C++退守到系统级别语言，成为软件工业的
基础是大势所趋。然而反思一下，真的是退守么？自从STL出现，无数的人风起云涌
的开始支持C++,他们狂呼“我看到深夜消失了，目标软件工程的出现。我看到了可
维护的代码。”是的，STL在可维护性下做得如此出色。但是又怎样呢？STL为C++铺
平了现代软件工程的道路，而在上层应用程序软件开发领域这块场地早不单独属于
C++,很多程序设计语言都做得很出色，疯狂的支持者会毫不犹豫地说我们应当支持
C++,因为它是世界上最棒的语言。而坦率地说，你的腰杆真的那么硬么？也许只是
在逃避一些事实。C++是优秀的，这不可否认，STL的出现让C++一度走上了最辉煌的
时刻，然而现在看来……我的一位恩师曾言：真正能够将STL应用得淋漓尽致的人很
保守地说国内也不超过200人，或许不加入STL能够使C++向着它应当发展的方向发展
的更好，而现在看来，C++也应当回首到真正属于他的那一片圣地上……

版权所有,转载请注明出处,勿用于商业用途,谢谢!

作者:    大宝天天见

Blog:    http://www.cppblog.com/singohgod

本人水平有限,有错请指出,欢迎交流,共同进步!

国内关于Lua的资料实在是太少,为了寻找一个合适的Lua的C++封装,真是如同大海捞针.在看了众多资料后锁定以下几种:LuaBind ToLua++ LuaPlus.在选择上颇有讽刺的味道,LuaBind的版本号还没到1.0,加上网友颇有微词,放弃.ToLua++本来有朋友推荐,但是怎么都找不到下载,官网就是打不开,无赖放弃.就只有LuaPlus了,看到一些人的评价还行,于是决定就用它吧.

LuaPlus的资料就更少了,连怎么配置怎么调试等什么都没有,只有沐枫大哥讲解了语法方面的一篇文章.啊哟,怎么搞呢,难道又只有硬着头皮上了?(某伟人曾说过,但凡杰出的事都是硬着头皮干出来滴)

好了,言归正传,下面讲讲我的经验吧:

如何编译

1.       下载

首先到官方网站下载: http://www.luaplus.org/

下载这个: All source code: http://luaplus.org/LuaPlus51_Build1100.zip (我当前的版本,当然越新越好)

2.       剥离

解开下载包,打开 \LuaPlus51_Build1100\Src\LuaPlus 里面是全部源文件,src下是lua的源文件.这里有个令人疑惑的地方,源文件中带了一些不需要的文件,要剔除去,基本上需要以下这些文件:

1)      Lua库文件:

lapi.c lapi.h lauxlib.c lauxlib.h lbaselib.c lcode.c lcode.h ldblib.c ldebug.c ldebug.h ldo.c ldo.h ldump.c lfunc.c lfunc.h lgc.c lgc.h linit.c

liolib.c llex.c llex.h llimits.h lmathlib.c lmem.c lmem.h loadlib.c lobject.c lobject.h lopcodes.c lopcodes.h loslib.c lparser.c lparser.h lstate.c lstate.h lstring.c

lstring.h lstrlib.c ltable.c ltable.h ltablib.c ltm.c ltm.h lua.h luaconf.h lualib.h lundump.c lundump.h lvm.c lvm.h lzio.c lzio.h print.c

2)      LuaPlus头文件:

auxiliar.h LuaAutoBlock.h LuaCall.h LuaFunction.h LuaHelper.h LuaHelper_Object.h LuaHelper_StackObject.h LuaLink.h LuaObject.h LuaObject.inl LuaPlus.h LuaPlusCD.h

LuaPlusFunctions.h LuaPlusInternal.h LuaStackObject.h LuaStackObject.inl LuaStackTableIterator.h LuaState.h LuaState.inl LuaStateOutFile.h LuaTableIterator.h luathread.h pt.h srm.h

3)      LuaPlus源文件

LuaCall.cpp LuaObject.cpp LuaPlus.cpp LuaPlusAddons.c LuaPlusFunctions.cpp LuaPlus_Libs.cpp LuaStackObject.cpp

LuaStackTableIterator.cpp LuaState.cpp LuaStateOutFile.cpp LuaState_DumpObject.cpp LuaTableIterator.cpp lwstrlib.c

3.       建立项目

然后你就可以在VS中建立一个新项目,静态链接库的:

分别把需要的文件加进去,之后编译,应该能通过了.

如何使用

接着讲讲如何在你的其他项目中使用LuaPlus.

1.必要的配置

你的项目可能是这样的:

设置GameClient的依赖项是LuaPlusLib

#include "LuaPlus.h"

using namespace LuaPlus;

记得干这事…

2.创建一个状态

LuaStateOwner state;

今后的操作都围绕这个state

3.执行脚本

int iret = state->DoFile("test.lua");

返回值为0表示成功,否则不成功.

4.C++中获取Lua脚本的变量

假设你的test.lua中有:

health = 200;

通过下列方法就可以在C++中得到这个数值

int mytest = state->GetGlobal("health").GetInteger();

5.C++中调用Lua脚本里的函数

假设你的test.lua中有:

function Add(x, y)

       return x+y;

end

在C++中需要先声明这个函数:

LuaFunction<float> Add =  state->GetGlobal("Add");

这样你就有了Add()这个函数,然后就可以像平常一样使用它了:

float myret = Add(3.14f,5.25f);

6.Lua脚本中调用C++函数

在读取test.lua之前要先把C++函数注册到Lua的运行时栈里,这样在执行lua脚本的时候,才知道执行哪一个函数:

首先有函数:

int LS_PrintNumber(LuaState* state)

{

LuaStack args(state);

       if (args[1].IsNumber()) {

              printf("%f\n", args[1].GetNumber());

       }

       return 0;

}

然后注册这个函数到Lua:

state->GetGlobals().Register("PrintNumber", LS_PrintNumber);

这样就把LS_PrintNumber映射为Lua中可以使用的函数PrintNumber.

Test.lua脚本中添加调用语句:

PrintNumber(30);

当state->DoFile("test.lua");执行的时候,就执行了C++中的这个函数.

总结

本文介绍了LuaPlus的基本配置方法和使用,希望对你有帮助.下一篇将介绍一些高级特性,如怎样在VS中调试LuaPlus的脚本,以及对类的操作等.

如果还有任何疑问可以看看下面这个简单的例子:
 /Files/singohgod/LuaPlus_Test.rar

在一个UI与逻辑模块交互比较多的程序中，因为并不想让两个模块发生太大的耦合，基本目标是
可以完全不改代码地换一个UI。逻辑模块需要在产生一些事件后通知到UI模块，并且在这个通知
里携带足够多的信息（数据）给接收通知的模块，例如UI模块。逻辑模块还可能被放置于与UI模
块不同的线程里。

最初的结构

最开始我直接采用最简单的方法，逻辑模块保存一个UI模块传过来的listener。当有事件发生时，
就回调相应的接口将此通知传出去。大致结构如下：

 /**//// Logic
 class EventNotify
 {
 public:
  virtual void OnEnterRgn( Player *player, long rgn_id );
 };

 /**//// UI
 class EventNotifyImpl : public EventNotify
 {
 };

 /**//// Logic
 GetEventNotify()->OnEnterRgn( player, rgn_id );

但是，在代码越写越多之后，逻辑模块需要通知的事件越来越多之后，EventNotify这个类开始
膨胀：接口变多了、不同接口定义的参数看起来也越来越恶心了。

改进

于是我决定将各种事件通知统一化：

struct Event
{
 long type; // 事件类型
  // 附属参数
};

这样，逻辑模块只需要创建事件结构，两个模块间的通信就只需要一个接口即可：

void OnNotify( const Event &event );

但是问题又来了，不同的事件类型携带的附属参数（数据）不一样。也许，可以使用一个序列化
的组件，将各种数据先序列化，然后在事件处理模块对应地取数据出来。这样做总感觉有点大动
干戈了。当然，也可以使用C语言里的不定参数去解决，如：

void OnNotify( long event_type, ... )

其实，我需要的就是一个可以表面上类型一样，但其内部保存的数据却多样的东西。这样一想，
模块就能让事情简单化：

template <typename P1, typename P2>
class Param
{
public:
 Param( P1 p1, P2 p2 ) : _p1( p1 ), _p2( p2 )
 {
 }
 
 P1 _p1;
 P2 _p2;
};

template <typename P1, typename P2>
void OnNotify( long event_type, Param<P1, P2> param );

GetNotify()->OnNotify( ET_ENTER_RGN, Param<Player*, long>( player, rgn_id ) );
GetNotify()->OnNotify( ET_MOVE, Param<long, long>( x, y ) );

在上面这个例子中，虽然通过Param的包装，逻辑模块可以在事件通知里放置任意类型的数据，但
毕竟只支持2个参数。实际上为了实现支持多个参数（起码得有15个），还是免不了自己实现多个
参数的Param。

幸亏我以前写过宏递归产生代码的东西，可以自动地生成这种情况下诸如Param1、Param2的代码。
如：

#define CREATE_PARAM( n ) \
 template <DEF_PARAM( n )> \
 struct Param##n \
 { \
  DEF_PARAM_TYPE( n ); \
  Param##n( DEF_FUNC_PARAM( n ) ) \
  { \
   DEF_MEM_VAR_ASSIGN( n ); \
  } \
  DEF_VAR_DEF( n ); \
 }

 CREATE_PARAM( 1 );
 CREATE_PARAM( 2 );

即可生成Param1和Param2的版本。其实这样定义了Param1、Param2的东西之后，又使得OnNotify
的参数不是特定的了。虽然可以把Param也泛化，但是在逻辑层写过多的模板代码，总感觉不好。

于是又想到以前写的一个东西，可以把各种类型包装成一种类型---对于外界而言：any。any在
boost中有提到，我只是实现了个简单的版本。any的大致实现手法就是在内部通过多态机制将各
种类型在某种程度上隐藏，如：

        class base_type
        {
        public:
            virtual ~base_type()
            {
            }
            virtual base_type *clone() const = 0;
        };
        
        template <typename _Tp>
        class var_holder : public base_type
        {
        public:
            typedef _Tp type;
            typedef var_holder<type> self;
        public:
            var_holder( const type &t ) : _t( t )
            {
            }

            base_type *clone() const
            {
                return new self( _t );
            }
        public:
            type _t;
        }

这样，any类通过一个base_type类，利用C++多态机制即可将类型隐藏于var_holder里。那么，
最终的事件通知接口成为下面的样子：

void OnNotify( long type, any data );

OnNotify( ET_ENTER_RGN, any( create_param( player, rgn_id ) ) );其中，create_param
是一个辅助函数，用于创建各种Param对象。

事实上，实现各种ParamN版本，让其名字不一样其实有点不妥。还有一种方法可以让Param的名字
只有一个，那就是模板偏特化。例如：

template <typename _Tp>
struct Param;

template <>
struct Param<void()>;

template <typename P1>
struct Param<void(P1)>

template <typename P1, typename P2>
struct Param<void(P1,P2)>

这种方法主要是通过组合出一种函数类型，来实现偏特化。因为我觉得构造一个函数类型给主模版，
并不是一种合情理的事情。但是，即使使用偏特化来让Param名字看起来只有一个，但对于不同的
实例化版本，还是不同的类型，所以还是需要any来包装。

实际使用

实际使用起来让我觉得非常赏心悦目。上面做的这些事情，实际上是做了一个不同模块间零耦合
通信的通道（零耦合似乎有点过激）。现在逻辑模块通知UI模块，只需要定义新的事件类型，在
两边分别写通知和处理通知的代码即可。

PS:
针对一些评论，我再解释下。其实any只是用于包装Param列表而已，这里也可以用void*，再转成
Param*。在这里过多地关注是用any*还是用void*其实偏离了本文的重点。本文的重点其实是Param：

OnNotify( NT_ENTER_RGN, ang( create_param( player, rgn_id ) ) );

->
void OnNotify( long type, any data )
{
 Param2<Player*, long> ParamType;
 ParamType *p = any_cast<ParamType>( &data );
 Player *player = p->p1;
 long rgn_id = p->p2;
}

下载相关代码