上上周末闲得无聊的时候画的：游戏引擎的大概架构图，图片源于Jason Gregory的《Game Engine Architecture》的第29页，这本书也基本上是围绕着这张图对每一个模块深入展开。这张图献给自己和其他游戏引擎架构研究的爱好者，应该打印一张贴到家里的剪贴板上。这段时间对我来说是一段困难的时期，不清楚未来是否还会在game的道路上走下去，但愿这不是一个终结。
runtime game engine architecture, from ‘Game Engine Architecture‘ P.29
在最近的项目中，由于时间紧任务重，我果断放弃了引擎原来有点畸形的多线程设计，退回到单线程。最后事实证明，这是一个明智的决定，不但效率没有降低，同时那些永无止境的多线程bug也一并被消除，系统稳定了很多，最终项目得以在deadline之前有一个安全的交付。
去掉多线程的主要原因是，原来的多线程设计本身就是一个未经过深思熟虑的设计，它几乎是在项目开发的中后期突然插入的。整个引擎的最初设计没有考虑多线程，现在突然引入了多线程，而又没有经过精心的设计，那结果就是各种多线程bug扑面而来，让开发人员焦头烂额。事实是，如果需要多线程，那最好应该从项目设计架构的第一天开始就仔细考虑。
直观上感觉，好像使用多线程就会带来性能的提升。其实不然，如果没有经过精心的设计，随便引入多线程，只会适得其反。不但性能没有得到提升，而且引入多线程后带来的庞大开发代价和潜在的多线程bug，会让你和团队崩溃到吐血，典型的吃力不讨好的事情。相比于单线程，引入多线程的设计需要带来2到3倍的开发和测试代价，在这么一个时间紧急的项目上，在项目的中后期突然引入多线程真是个大错特错的决策，应该果断拿掉。在这篇博客文章“一种3D引擎的多线程设计方案”里，作者就提到，“多线程的引入使引擎变得更加复杂，不良的设计带来的性能提升非常有限，甚至在单核环境下还会出现明显的性能下降”。
从这篇Unreal引擎工程师Tim Sweeney的访谈文章中，我找到了在我的情况中应该拒绝多线程的另一个重要原因。
Tim提到：
For multithreading optimizations, we’re focusing on physics, animation updates, the renderer’s scene traversal loop, sound updates, and content streaming. We are not attempting to multithread systems that are highly sequential and object-oriented, such as the gameplay.
This is also why it’s especially important to focus multithreading efforts on the self-contained and performance-critical subsystems in an engine that offer the most potential performance gain. You definitely don’t want to execute your 150,000 lines of object-oriented gameplay logic across multiple threads – the combinatorical complexity of all of the interactions is beyond what a team can economically manage. But if you’re looking at handing off physics calculations or animation updates to threads, that becomes a more tractable problem.
Tim的主要思想是，游戏引擎多线程应该关注在“独立自主且性能关键的子系统”上，比如物理系统或者是动画系统，这会带来最大的性能提升。而在我的项目中，多线程是放在了脚本(scripting）层，这正中了上面Tim所提到的多线程的雷区——gameplay。脚本是处理gameplay层次的逻辑的，它是高度顺序且面向对象的，并且与其他各个子系统有着千丝万缕的关联。正如Tim所说的，将脚本逻辑放到多线程来执行所带来的交互的复杂度已经超过一个团队的承受范围了。
从这篇文章中我们也可以获知，像Unreal这样知名的商业引擎，也是到最新的第3版（这种称为下一代的游戏引擎）中才开始支持了多线程，这从一个侧面反映了多线程技术在游戏引擎中是一项高级而复杂的技术。主要原因这受制于硬件的发展，多核CPU的PC是到近些年才开始在市场中变为主流，在单核CPU中使用多线程会带来额外的开销，所以在传统的游戏开发中，往往都是单线程的。（这里是一个很好的关于用户软硬件使用情况统计的网站，不过遗憾的是统计数据基本都是来源于国外，不带中国人玩的，对于国内没什么参考价值）
另外对于游戏引擎引入多线程的考虑，还有很重要的一点是，我们需要认真的考虑当前引擎的性能具体是受限在哪里，是CPU还是GPU，我们该在哪里进行优化。因为GPU渲染在游戏中是如此的重要，所以在大多数情况下，很可能GPU才是主要的性能瓶颈。只有真正的当物理，AI等这些模块变得越来越重要，并且约束系统性能时，我们才需要仔细考虑是否需要为游戏引擎带来多线程的可能。
总之，多线程就是一把双刃剑，在决定使用它之前，一定要经过明智而审慎的思考和设计。
对于游戏引擎的多线程设计，最近读到了一些相当不错的文章，在这里作个整理。
Gamasutra上的Multithreaded Game Engine Architectures是一篇非常基础且有意思的文章。
该文章首先指出，程序并行有两种主流的方式，第一种称为函数并行(functional parallelism)，另一种称为数据并行(data parallelism)。所谓functional parallelism，即将程序中不同的任务分配给不同的线程并行执行，而data parallelism则是将数据划分到不同的线程上并行执行，但每一个线程执行的是相同的任务。这样的分类比较利于我们更好的理解程序并行的行为，我们可以在很多地方看到有这样的分类，比如在Intel的这篇关于并行引擎架构的文章中，提到了类似的functional decomposition和data decomposition，而John Owens在Siggraph 2008的talk “Parallel Programming Models Overview”中，也提到了这样的分类，他称之为task parallelism和data parallelism.
基于这些并行方式，该文章提出了游戏引擎多线程的3种架构。
前两种架构都是基于functional parallelism的方式，第一种架构称为同步的函数并行模型（synchronous function parallel model），是最常见的一种游戏引擎多线程方式。该方式保留传统的game loop，将完全独立的子系统的任务分离到辅线程，并与主线程并行执行，每帧作同步。Intel的Multi-threaded Rendering and Physics Simulation这篇文章就是这种方式的典型。
第二种架构称为异步的函数并行模型 （asynchronous function parallel model），是一种非常新颖而前瞻的架构，它脱离了传统的game loop，各个子系统跑在各自的线程上，并按自己的节奏拥有独立的game loop，该架构拥有非常好的可扩展性，但难点就是不同子系统之间的数据同步问题。对于这种架构方式，Intel的这篇Designing the Framework of a Parallel Game Engine是一篇非常棒的文章，极力推荐，该文章提出了Free Step Mode和Lock Step Mode两种并行执行的模式，不仅仅是并行架构，从这篇文章中还能学到其他很多关于游戏架构的知识。
第三种架构是基于data parallelism的方式，文章中称之为数据并行模型（data parallel model）。这种方式我们并不陌生，比如我们经常听到的GPGPU就是这种方式在GPU上的体现，另外我们所熟知的SIMD（Single Instruction Multiple Data）,SPMD（Single Program Multiple Data）技术都是这种方式的典型。该方式可以获得最大的并行性，但缺点是采用数据并行的系统往往非常难于设计，通常需要修改原来的面向对象的设计。可以看看Intel的这篇TickerTape的文章，利用SIMD技术提升性能，但却需要破坏原有的类的设计，将结构数组（Array of Structures）改为数组结构（Structure of Arrays）。
关于更多的游戏引擎和多线程的资源，可以参见这里。
花了圣诞节的时间，为之前的听写播放器又做了一点更新，增加了3个小的feature。
截图：
感谢好友Shawn（另一个VOA听写狂）帮我测试使用DictationPlayer，并提出了很多很好的意见和建议，thank you so much，你还得继续帮我:D.
最近干了一件很抽风的事情，花了几个晚上，用最新的Flex Builder 4开发了一个简单的听写播放器，我已经两年多没碰过flash开发了。
之前一直在沪江英语上做听写，觉得它的听写播放器用起来很方便，F7/F8两个快捷键让听写哗哗的舒适。不过遗憾是它只能在沪江上用，不能对本地的音频或视频文件使用。自己也尝试用过一些其他的听写播放器，不过总觉得不如沪江的用户体验好。然后当自己想听写一些比如电影片段，或者一些跟我的本行Computer Science相关的一些presentation的时候，就比较麻烦了。于是，为了自己在做这些听写的时候不这么抽风，就干了这么一件抽风的事情。
可以在这里下载到这个类似于沪江听写播放器的DictationPlayer，只有几百K，是一个Flash Air程序，安装需要有Flash的air安装管理器。非常的粗糙而简单，我开发的本质目的还是为了方便自己的听写，并且如果可能的话，为可能有类似需求的听写热爱者提供点便利，那将是我最大的荣幸。
以下是对这个DictationPlayer的简单介绍。
它能做的：
它不能做的：
这个是它的界面（说点题外的，最近在听写Google的一个技术talk – How to Design a Good API and Why it Matters，我个人觉得听写并练习这样的技术talk是非常好的，可以三面获利，首先肯定提高英语，其次这样好的技术talk绝对增加自己技术上的专业知识，最后，如果够疯狂，能够模仿并练习这些talk，对于自己做英文presentation绝对是个很大的提升，因为这些人都是非常棒的speaker）
简单的几个快捷键：
如果你的电脑没有安装Adobe Air，请先到此处下载安装：http://get.adobe.com/air/，因为安装并运行播放器需要它。
巴萨万岁！
上一篇文章提到了在Lua中实现类似于JavaScript中的eval函数，遗憾是该eval函数不支持赋值语句，原因是Lua的赋值运算符是不支持返回值。所以如果要让该eval函数也支持赋值语句，就需要一个额外的工作，让它鉴别一个语句是不是赋值语句，如果是，则return的是被赋值后变量的值。为此，我写了一个isAssignmentExpression函数，比较粗糙，不过够用了，基本思想是检测语句中第一个出现的”=“操作符，且该”=“不能在一对引号当中。
-- Lua code
function isAssignmentExpression( str )
local i = 1;
local curChar;
local quotesType = "none" -- none, single or double
local isEscaping = false
curChar = string.sub( str, 1, 1 )
while ( curChar ~= "" ) do
if ( curChar == "'" and
isEscaping == false and
quotesType ~= "double" )
then
if ( quotesType == "single" )
then quotesType = "none"
elseif ( quotesType == "none" )
then quotesType = "single"
end
end
if ( curChar == """ and
isEscaping == false and
quotesType ~= "single" )
then
if ( quotesType == "double" )
then quotesType = "none"
elseif ( quotesType == "none" )
then quotesType = "double"
end
end
if ( curChar == "\" and isEscaping == false )
then isEscaping = true
else isEscaping = false
end
if ( curChar == "=" and quotesType == "none" )
then
if ( string.sub( str, i+1, i+1 ) ~= "=" )
then
return true, string.sub( str, 1, i - 1 )
else
return false
end
end
i = i + 1
curChar = string.sub( str, i, i )
end
return false
end
function eval( str )
local bAssign
local var
bAssign, var = isAssignmentExpression( str )
if ( bAssign )
then
print( "Assignment, var=" .. var )
loadstring( str )()
return loadstring( "return " .. var )()
else
return loadstring( "return " .. str )()
end
end
-- 以下是一组测试
print( eval( "3+4" ) )
-- 7
function Multiply( a, b )
return a*b
end
print( eval( "Multiply( 3, 4 )" ) )
-- 12
print( eval( "i" ) )
-- nil
print( eval( "i = 1" ) )
-- Assignment, var=i
-- 1
print( eval( "i = i + 1" ) )
-- Assignment, var=i
-- 2
print( eval( "i" ) )
-- 2
print( eval( "i+1" ) )
-- 3
print( eval( "i, j = 4, 5" ) )
-- Assignment, var=i, j
-- 4 5
print( eval( "i = {}" ) )
-- Assignment, var=i
-- table: 003CD818
print( eval( "i[ "0" ] = 0" ) )
-- Assignment, var=i[ "0" ]
-- 0
print( eval( "i[ "\"0=" ] = 1" ) )
-- Assignment, var=i[ ""0=" ]
-- 1
print( eval( "i.name="hello"" ) )
-- Assignment, var=i.name
-- hello
print( eval( "i[0], i.name = 4" ) )
-- Assignment, var=i[0], i.name
-- 4 nil
print( eval( "i == 10" ) )
-- false
使用luaL_optstring, luaL_optnumber, luaL_optinteger等Lua API，如下示例，函数有一个默认字符串参数，默认值为””，这样在Lua中调用whatever的时候，whatever()或者whatever( “whatever”）均可。（Oh…whatever…随便…都行…）
// C code
int Whatever( lua_State *L )
{
string str = luaL_optstring( L, 1, "" );
//...omitted code...
}
lua_register( L, "whatever", Whatever );
使用luaL_checkoption这个Lua API，它可以把从Lua传来的string转换为相应的C string array中的index，从而可以建立Lua字符串和C enum的映射。以下是个简单的示例：
// C code
enum PlayerType
{
PLAYER_TYPE_UNDEFINED = -1,
PLAYER_TYPE_KING = 0, // 主公
PLAYER_TYPE_INSURGENT, // 反贼
PLAYER_TYPE_LOYAL, // 忠臣
PLAYER_TYPE_TREACHEROUS, //内奸-_^
NUM_PLAYER_TYPE // just a sentinel
};
const char * const PlayerTypeList[NUM_PLAYER_TYPE + 1] =
{
"KING",
"INSURGENT",
"LOYAL",
"TREACHEROUS",
NULL
};
static int testPlayerType( lua_State *L )
{
PlayerType type = static_cast< PlayerType >(
luaL_checkoption( L, 1,
"INSURGENT", PlayerTypeList ) );
std::cout << "Type index is " << type
<< " - " << PlayerTypeList[type]
<< std::endl;
return 0;
}
lua_register( L, "setPlayerType", setPlayerType )
首先enum PlayerType定义了一组角色类型，来自人人都爱的三国杀:-)。
接着PlayerTypeList定义了一个字符串数组，给Lua使用。注意需要保证enum和字符串数组的对应，比如PlayerTypeList[PLAYER_TYPE_KING]是“KING”，同时，PlayerTypeList必须以NULL结尾。
在定义给Lua的函数testPlayerType中，就可以用luaL_checkoption将Lua传来的字符串参数转换为相应enum的值。luaL_checkoption还支持默认参数，比如在上面例子中，将第三个参数设为“INSURGENT”，如果Lua中没有提供任何参数，则PlayerType就为与“INSURGENT”相对应的PLAYER_TYPE_INSURGENT。
以下是一组测试及结果：
--Lua code testPlayerType( "KING" ) -- Type index is 0 - KING testPlayerType() -- Type index is 1 - INSURGENT testPlayerType( "whatever" ) -- bad argument #1 to 'testPlayerType' (invalid option 'whatever')
众所周知，JavaScript中有一个著名的eval函数，它用于把一个字符串当作一段JS代码去执行，在Lua中没有提供类似的函数，但稍微包装下Lua的库函数loadstring即可实现，以下是代码。
--Lua code function eval( str ) local func = loadstring( "return " ..str ); return func() end
这样已经可以了，不过相比于JS的eval函数，功能稍微差一些，因为它不支持赋值语句，这是Lua语言天然的原因，因为Lua的赋值运算符没有返回值，在其他语言中常见传递赋值的“i=j=1”（先赋值j=1，然后将(j=1)的返回值j赋值给i），在Lua中是不允许的。所以当eval执行的是赋值运算（比如i=1）的时候，return i=1就会出错。
下面是一些测试例子：
--Lua code print( eval( "3+4" ) ) -- OK, 打印7 function Multiply( a, b ) return a*b end print( eval( "Multiply( 3, 4 )" ) ) -- OK，打印12 print( eval( "i = 1" ) ) -- 错误， attempt to call a nil value i = 1 print( eval( "i" ) ) -- OK，打印1 print( eval( "i = i + 1" ) ) -- 错误， attempt to call a nil value
不知道为什么Lua的API没有提供luaL_checkbook函数，不过很容易实现：
// C code
BOOL luaL_checkbool( lua_State *luaVM, int numArg )
{
BOOL b = FALSE;
if ( lua_type( L, numArg ) == LUA_TBOOLEAN )
{
b = lua_toboolean( L, numArg );
}
else
{
luaL_typerror( L, numArg, lua_typename( L, LUA_TBOOLEAN ) )
}
return b;
}
这个问题的具体描述是——C注册给Lua一个函数，但Lua调用该C函数并不能立即获得结果（比如需要访问远程服务器获取值），如何能让Lua停止并等待，直到获取到结果后，才继续执行接下来的脚本。
举个例子，比如说有一个C函数login，我们试图通过调用该函数以执行用户的登录操作并获取验证结果。首先看下面这段C代码：
// C code
int login( lua_State *L )
{
string user = luaL_checkstring( L, 1 );
string password = luaL_checkstring( L, 2 );
// 该函数将user和password发送到服务器后立即返回，
// 绝不要在此处阻塞，这将严重影响效率
sendAuthenticationInfo( user, password );
return 0;
}
// 注册给Lua
lua_register( L, "login", login );
可以看到，因为该函数需要访问远程的登录服务器，在系统中一般都采取异步操作（让系统阻塞等待结果是不可接受的）。但是这样Lua开发人员调用login函数时，也只能异步等待结果，下面是Lua中处理登录操作的代码。
-- Lua code -- 当用户点击“登陆”按钮后，执行该函数 function onClickLoginBtn() local user = ... local password = ... login( user, password ) -- 只是发送login命令 end --当获取login结果后的回调函数 function onGetLoginResult( bPass ) if bPass == true then print( "Authentication succeeded." ) ...omitted code... else print( "Authentication failed." ) ...omitted code... end end
这段Lua代码很好理解，首先onClickLoginBtn是一个按钮事件处理函数，当用户点击了”登录“按钮后，会触发该函数。该函数首先从界面上获取用户输入的user和password，然后调用了上面C中所定义的login函数。正如前面的C代码所写的，login函数不会马上得到认证结果，所以执行后马上退出。另一个函数是onGetLoginResult，这个Lua函数需要当C系统中获取到认证结果后被回调执行，以真正执行login的后续操作。所以，我们还需要在C中添加回调的代码。
// C code // 当服务器端返回认证结果后 BOOL loginResult = ... lua_getglobal( L, "onGetLoginResult" ); lua_pushboolean( L, loginResult ); lua_call( L, 1, 0 );
在这里，我们在C中hardcode了回调onGetLoginResult的代码，这很丑陋，不过可以避免，比如可以给前面注册给Lua的login函数增加一个参数callbackFunctionName，以让Lua显式的告诉系统当获取登录结果后的回调函数名称。
再次回到本文一开始所提出的问题，尽管在系统中的异步调用不可避免，但我们希望在Lua中能够有同步机制，即Lua脚本在得到验证结果后才允许被继续执行，如何才能做到这一点呢。
Lua有一个非常棒的coroutine机制，在Lua代码中可以通过协同程序来进行多线程，可以使用coroutine.yield和coroutine.resume来对协同程序进行挂起和恢复。需要达到上面所提出的目标，只需在系统中使用与coroutine.yield和coroutine.resume相对应的Lua C API——lua_yield和lua_resume即可。如下所示，login函数有些小改变：
// C code
int login( lua_State *L )
{
string user = luaL_checkstring( L, 1 );
string password = luaL_checkstring( L, 2 );
sendAuthenticationInfo( user, password );
return lua_yield( L, 0 );
}
// 注册给Lua
lua_register( L, "login", login );
可以看到，与前面的区别只有login函数的最后一句，调用了lua_yield后再返回，而不是return 0，这样就可以达到阻塞Lua脚本的目的。事实是，lua_yield是一个比较特殊的函数，它只能作为注册的C函数的返回值使用，否则调用失败。
当系统获得服务器端的登陆验证结果后，通过lua_resume即可恢复之前被阻塞的Lua。
// C code // 当服务器端返回认证结果后 BOOL loginResult = ... lua_pushboolean( L, loginResult ); lua_resume( L, 1 );
上面的代码是当你的系统中只有一个Lua虚拟机的情形，如果使用了多个Lua虚拟机，事情稍微有一点点复杂，login函数还需要将当前调用的lua_State存储下来，以便lua_resume的时候，可以知道恢复的是哪一个被阻塞的虚拟机。
OK，当C中有这样的实现后，Lua程序人员将会为此而高兴，因为Lua代码变得如此简洁。
-- Lua code -- 当用户点击“登陆”按钮后，执行该函数 function onClickLoginBtn() local user = ... local password = ... if login( user, password ) == true then print( "Authentication succeeded." ) ...omitted code... else print( "Authentication failed." ) ...omitted code... end end
系统or平台开发人员应当尽可能的为用户考虑，正如上面第二种解决方法所追求的那样。
需要同时链接”dl“库
需要下载并安装GNU Readline Library
1: 不推荐的解决方式：将Project Properties->Configuration Properties->General下的Character Set从unicode改成multi-set；
2: 彻底的解决方式，参考此链接：http://lua-users.org/lists/lua-l/2006-06/msg00427.html
调用LuaAPI – lua_dump
关于lua_dump: about lua_dump: Dumps a function as a binary chunk. Receives a Lua function on the top of the stack and produces a binary chunk that, if loaded again, results in a function equivalent to the one dumped. As it produces parts of the chunk, lua_dump calls function writer (see lua_Writer) with the given data to write them.
void BeginLuaLibCall( lua_State *L, const string &libName, const string &functionName )
{
lua_pushstring( L, libName.c_str() );
lua_gettable( L, LUA_GLOBALSINDEX );
lua_pushstring( L, functionName.c_str() );
lua_gettable( L, -2 );
}
void EndLuaLibCall( lua_State *L )
{
lua_pop( L, -1 );
}
示例：调用table.getn（该函数用来获取一个table的size）
// 利用上面的函数 BeginLuaLibCall( L, "table", "getn" ); // 假设你的脚本中有一个table变量myTable，获取它到栈顶 lua_getglobal( L, "myTable" ); // 执行table.getn( t ) lua_call( L, 1, 1 ); // 打印结果 std::cout << lua_tonumber( L, -1 ) ) << std::endl; // 将结果弹出栈 lua_pop( L, -1 ); // 将名叫“table”的table弹出栈 EndLuaLibCall( L);
模板在C++中本来就是个比较复杂的领域，而当它和DLL结合到一起时，事情变得更加有点复杂而有趣，最近就遇到了这样一个问题。
我有一个用于生成单件的类模板，它声明在一个DLL项目中，如下。
#if defined MY_EXPORTS
#define EXPORT_API __declspec(dllexport)
#else
#define EXPORT_API __declspec(dllimport)
#endif
template < typename T >
class Singleton
{
public:
EXPORT_API static T& GetSingleton()
{
static T singleton;
return singleton;
}
// ...省去其它代码，比如隐藏构造函数，禁止复制构造和赋值函数..
};
我试图导出GetSingleton()函数，因为我希望在其他导入该DLL的模块中能够通过调用这个函数而得到单例。基于该Singleton类模板定义一个单件的类很简单，只需要继承实例化的类即可，比如我在DLL内部定义了两个单件类，LogManager和ResourceManager，他们的定义看起来像这样。
class LogManager : public Singleton< LogManager >
{
// ......
}
class ResourceManager : public Singleton< ResourceManager >
{
// 该类因为需要记录日志，会使用LogManager类
// ......
}
OK，DLL编译通过。然后，我在另一个项目模块中导入该DLL，我需要在这个模块中使用LogManager类和ResourceManager类，由于它们都是单件，正如前面所说的，我通过GetSingleton()函数得到单例，以访问它们的其它接口。
LogManager::GetSingleton()->... ResourceManager::GetSingleton()->...
然而，状况出现了，build该模块时出现了链接错误：unresolved external symbol “public: static class ResourceManager & __cdecl Singleton::GetSingleton(void)”” ，提示死活链接不到ResourceManager的GetSingleton()函数，然而同样是使用Singleton模板，LogManager的GetSingelton()函数却是链接成功的。
如果足够了解template的机制，就很容易找到问题所在。问题的原因是，除非你显示的实例化（或者调用）了某个模板函数，否则这个模板函数在编译生成代码中（.obj）是根本不存在的。所以，尽管我们为模板函数打上了export的标签，但其实什么也没有导出。而LogManager能链接成功，是因为它在DLL中（ResourceManager中）有使用，从而编译器生成了LogManager::GetSingleton()并导出。
所以，为了能够同样也导出ResourceManager::GetSingleton()，我们必须在DLL中提前显示的实例化它（explicit instantiation）。
LogManager和ResourceManager都是在DLL内部定义的单件类，那能不能在DLL外部也基于Singleton模板快速定义单件类呢？可以，不过GetSingleton这个函数对于其它模块就是隐形的了（根本不存在），你只能在每一个单件类中重新定义一个GetSingleton函数，以避免链接错误。
这个问题有没有完美的解决方案呢，即我们能否让一个模板函数完全导出，使得在别的模块中也可以自由的基于任意类型实例化函数呢？
去google上试图寻求答案，无果。不过说这个问题还真不少，比如CodeProject上的这篇文章：http://www.codeproject.com/KB/cpp/MemberTemplateDLL.aspx 。它提出可以使用inline的方式来解决这个问题，但不保证结果，因为本来编译器对于inline的处理就是个未知的行为。他同时还提出，这可能是一个跟编译器相关的问题，因为对于模板的处理是个跟编译器密切相关的行为。该作者在VC6.0上遇到了这个问题，我的是在VS2005（VC8.0）上，在其他不同平台或版本的编译器上会怎样我也没有测试过。
总之，记住很重要的一点，当导出一个模板函数时，需要格外的警惕。在MSVC编译器上，只有在DLL中被显示的实例化的版本，相应的函数才会被导出。
PS：写于Costa Coffee@中关村，卡布奇诺喝得有点儿恶心了:-)
Recent Comments