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

// 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')

--Lua code
function eval( str )
	local func = loadstring( "return " ..str );
	return func()
end

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

// 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函数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平台开发人员应当尽可能的为用户考虑，正如上面第二种解决方法所追求的那样。

我有一个用于生成单件的类模板，它声明在一个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中被显示的实例化的版本，相应的函数才会被导出。

状况 | Case

因为GFW的关系，越来越多的网友熟练掌握了使用SSH Tunnel“翻墙”的方法——这种方法使我们通过墙外一台主机作为代理中转访问国际互联网。网上关于SSH翻墙的文章已经很多，无须赘述，提及此只为特别感谢郭嘉。
少数情况下，我们不仅需要翻出墙，可能还需要从墙外翻回来。比如你交友不慎，某个邪恶国家友人强烈要求感受一下国内的网络环境;你如此勤奋以至于希望在家中仍然能够连接到公司网络开工，公司却出于体恤员工的考虑没有提供VPN，此时就需要手段先“翻”到公司的院子里。反向的SSH Tunnel就是这样的手段。

原理 | Principle

反向SSH Tunnel原理

实例 | Practice

用到反向SSH Tunnel，是因为之前有这样一个需求：我们有一个开发中的网站，将要在外部Web Server（Host A）上布署测试环境，需要在外部主机上获取代码并持续更新。代码通过公司内部的SVN Server（Host S）进行版本控制，公司外部无法访问。我们不希望在外部主机上通过VPN一类软件登录公司网络，而是在必要的时候由内部网络发起连接。因此我们使用反向SSH Tunnel。
创建反向SSH Tunnel的过程由内网的桌面（Host B）来完成

如

输入密码确认后，一个从desktop:8080到www.example.com:9090的反向Tunnel就建好了。在Host A上用

将看到9090端口已经在监听。此后发往www.example.com:9090的请求将被通过Tunnel转送到desktop:8080。
接下来我们对转发到Host B的8080端口上的请求做处理。在本例中，我们使用Apache Server的Proxy Module来转发请求。为此，首先要确认Apache有安装好mod_proxy和mod_http_proxy。然后，在Apache中添加虚拟主机，配置如下：

此配置将在8080端口上建立虚拟主机，并将发往此主机的所有请求转发到http://svn.company-domain.com/。
这样，一个完整的Reverse SSH Tunnel就建好了。在SSH Tunnel连通时，我们可以使用svn co http://172.0.0.1:9090/trunk/myproject/…/在Host A上下载源码。这个请求首先通过Tunnel进入公司网络，被转发到desktop:8080。然后，再被Apache根据mod_proxy的设置转发到svn.company-domina.com。SVN Server的响应也会按照原路逐级转发回到外部主机Host A。当然，我们也可以再做一些锦上添花的工作比如修改Host A上的本地DNS，将svn.company-domain.com解析到127.0.0.1。
当必要的任务完成后，只要在Host B上断开SSH连接，外部主机Host A将没有办法访问内部网络。

更多 | More

以上只是实现了一个基本的反向SSH Tunnel实例，在此基础上我们还可以做很多，比如最重要的安全策略。我们可以在Host A（www.example.com）上限制对9090（PORT_A）的访问，在Host B上对SSH Server和Apache Proxy做相应的权限，日志等设置。
另外，虽然从安全模型上说，这种由内部网络主动发起并且可控的连接是可以信任的，但是此办法实质是在公司防火墙上开了个后门。所以在使用前还是要看看公司安全规定有否相关约束。
关于SSH用法还有无数的内容，部分可参考下面的资源。

资源 | Resource

Secure Shell
Setting up a reverse SSH tunnel
深入讲解SSH协议的转发概念
反向建立 SSH Tunnel、免 VPN 連回公司
上班族ssh tunnel求生手冊
SSH Tunnel扫盲

module就是我所写的模块，在这里被封装为DLL，因为要使用json相关的功能，该DLL链接了一个静态库 (jsoncpp.lib)。最后在应用程序中导入并使用module.dll，同时因为在应用程序中也需要用到json，所以应用程序也链接了jsoncpp.lib。

以下用一些伪代码来描述这些模块间的调用关系，以具现出这个错误。

jsoncpp.lib为c++提供了功能齐全的json操作，其核心的类是Json::Value。（阅读本篇文章你无需了解太多json）

module.dll中导出了一个接口：

//ModuleClass.h
#include "json/value.h"

#if defined MODULE_EXPORTS
#define MODULE_EXPORTS __declspec(dllexport)
#else
#define MODULE_EXPORTS __declspec(dllimport)
#endif

class ModuleClass
{
public:
	MODULE_EXPORTS void AllocSomeMemory( Json::Value &root )
	{
		// 这将申请一些内存，因为会new出一个Json::Value，并append到root上
		root.append( "testString" );
	}
};

应用程序：

#include "json/value.h"
#include "ModuleClass.h"
int main()
{
	Json::Value root;
	ModuleClass::AllocSomeMemory( root );
}

在Debug模式下，当main函数执行完毕，对Json::Value root进行析构时，程序便出现了异常。分析下，很显然，调用ModuleClass::MallocMemoryHere时申请的内存，是在module.dll中申请的，而对这些内存的析构则是在应用程序（.exe）中进行的（析构root会同时析构append在root上的所有子Json::Value）。不过，这是异常的真正原因么？

追踪到异常的出错点：dbgheap.c文件中那句ASSERT语句。

/*
* If this ASSERT fails, a bad pointer has been passed in. It may be
* totally bogus, or it may have been allocated from another heap.
* The pointer MUST come from the 'local' heap.
*/
_ASSERTE(_CrtIsValidHeapPointer(pUserData));

注释中的最后一句话”The pointer MUST come from the ‘local’ heap“引起了我的警惕，难道对于内存的申请和释放不是在同一个heap上，除了‘local’ heap还有一个什么heap么。

去MSDN上搜索了关于_CrtIsValidHeapPointer，似乎找到了答案，以下这段话是MSDN上对于_CrtIsValidHeapPointer的介绍：

The _CrtIsValidHeapPointer function is used to ensure that a specific memory address is within the local heap. The local heap refers to the heap created and managed by a particular instance of the C run-time library. If a dynamic-link library (DLL) contains a static link to the run-time library, it has its own instance of the run-time heap, and therefore its own heap, independent of the application’s local heap. When _DEBUG is not defined, calls to _CrtIsValidHeapPointer are removed during preprocessing.

注意字体加粗的部分，这不正应对我的情形么？！错误不在于DLL中申请的内存在EXE中释放，而在于如果这个DLL拥有一个静态链接，它就会拥有独立的运行时堆，独立于应用程序的堆。这样对于内存申请和释放并不是在同一个堆上进行的，当然出错了。

解决：虽然MSDN上最后说，如果把项目改成release的，这个ASSERT就将避免，但这是放纵内存泄露，最好的解决办法是将静态链接也改成动态链接，这样就使得DLL能够和应用程序共享同一个堆，错误也得以避免。

于是，我修改了jsoncpp的项目配置，生成jsoncpp的动态链接库，而不是使用静态库，重新导入到module.dll中，错误解决。

Whatever.h

#include <vector>
#include <string>
class Whatever
{
public:
	Whatever()
	{
		cout << "Construct Whatever" << endl;
		Display();
	}
	~Whatever()
	{
		cout << "Destruct Whatever" << endl;
		Display();
	}
	void Display()
	{
		cout << "static int:" << i << endl;
		cout << "static string:" << m_str << endl;
		cout << "static vector:" << m_vec.front() << endl;
	}

private:
	static int i;
	static std::string m_str;
	static std::vector<char> m_vec;
};

Whatever.cpp

#include "Whatever.h"

int Whatever::i = 500；
string Whatever::m_str = "something";
vector<char> Whatever::m_vec = vector<char>( 10, 'a' );

一个简单的类，Whatever，包含几个static成员变量，然后在构造函数和析构函数中都分别打印这些静态变量的值，乍一看似乎没什么问题，但却有潜在的SIOF的风险。我们容易默认为在调用Whatever的构造函数的时候，Whatever空间中的static的成员变量已经被初始化了，其实不然，现在制造一个SIOF引起crash的情形：

#include "Whatever.h"
Whatever g_whatever;
int main()
{
	...
}

因为g_whatever是global变量，所以最先被初始化，在调用Whatever的构造函数的时候，Whatever空间的静态成员变量还未被初始化，所以访问这些静态变量肯定出错。在VS的编译器下测试的结果：

Construct Whatever
static int:5
static string:
（调用m_vec.front()导致程序crash）

奇怪的是对于int这种built-in的类型却能得到正确的值，不知编译器在背后都做了哪些手脚，猜想可能是在程序编译的时候他们就被值替换了。而string和vector应该都属于自定义类型（初始化需要调用构造函数），未初始化之前访问肯定是错误的，所以打印出的string是个空值，而访问一个空的vector的front元素则直接造成程序crash。

根据初始化和释放的对称关系，所以在析构函数中访问这些静态变量同样也是失败的，因为在析构g_whatever的时候，Whatever空间的静态变量已经被解决掉了。

SIOF是非常难于检测的问题，这个例子是一种最简单的情形，在我的项目中，我并没有定义什么global的成员，但是因为使用了很多前置声明（forward declaration），还有一些Singleton，造成了一个非常隐蔽的SIOF，花了很大的力气才找到，痛苦的过程。

要解决SIOF问题，需要用一个function来包装static变量，即利用函数内static变量的construct-on-first-use特性。

修改后的Whatever.h

class Whatever
{
public:
	Whatever()
	{
		cout << "Construct Whatever" << endl;
		Display();
	}
	~Whatever()
	{
		cout << "Destruct Whatever" << endl;
		Display();
	}
	void Display()
	{
		cout << "static vector:" << GetStaticVector().front() << endl;
	}

private:
	vector<char>& GetStaticVector()
	{
		static vector<char> vec = vector<char>( 10, 'a' );
		return vec;
	}
};

用GetStaticVector来包装之前所需要的静态的vector，就能保证在调用的时候，它一定已经被初始化了。再次运行之前的测试程序，OK了。

总之，我们对于static变量的使用要保持一颗警惕的心，如果不确定在使用时它是否已经被初始化，就要使用函数包装static变量来防止Static Initialization Order FIASCO!
Fiasco, what a cool word.

在Lua中，几乎所有的东西都是围绕着lua_State转，所以，一般我们都会写一个类来封装管理它，比如：

class LuaObject
{
public:
	LuaObject()
	{
		m_L = luaL_newstate();
		luaL_openlibs( m_L );
	}
	~LuaObject()
	{
		if ( m_L )
		{
			lua_close( m_L );
			m_L = NULL;
		}
	}

private:
	lua_State *m_L;
};

这很好，不过它不是指针安全的。试想，如果一个LuaObject对象被复制，结果将会怎样。

LuaObject luaObject1;
LuaObject luaObject2( luaObject1 );

上面这段代码将会导致运行时crash，因为luaObject1和luaObject事实上指向了同一块lua_State，这样当luaObject1和luaObject2被析构时，lua_State会被两次lua_close，这不crash才怪呢！

事实是，当一个类包含了一个指针时，我们就需要开始变得格外谨慎，除了在构造函数和析构函数中要处理指针的初始化和清理外，我们还需要考虑深拷贝（deep copy），浅拷贝（shallow copy)）的问题。如果使用编译器默认生成的拷贝构造函数，它只会浅拷贝指针，而指针所指向的内存区域不会被拷贝。就像上面一样，两个LuaObject实则共享了一个lua_State。

那该如何处理让管理LuaObject类的指针安全呢，深拷贝？厄，首先我也没有深究深度拷贝lua_State具体该如何完成，不过我猜想这可是一个复杂而重型的操作，仅仅为了带来指针安全而选择此可不是一个明智的选择。

如果你是开发LuaObject类的程序员，也许你会对使用LuaObject的程序员（或许有时使用者就是你自己）说：“你不要对它进行拷贝操作不就OK了”，但这是一种严重不负责任的行为，因为这种皮球会越踢越远的。比如，程序员A使用了你的LuaObject类，他写了一个包含LuaObject的指针的类，同样A也不考虑拷贝指针安全问题，然后A又将它的类传递给了B，B封装了A的类指针，然后传递给了C，接着如此重复，C再给D，D再给E，最后E在对类进行拷贝操作时，程序crash掉了，因为在某个最底层，他们共享了lua_State。不过因为这时候已经嵌套了这么多层，E程序员或许根本不知道也不关心什么是LuaObject（他只跟D的类打交道）。这时，要想追踪到BUG之源——万恶的不考虑指针安全的LuaObject，已经非常困难了，God bless you all.

事实是，如果你不想让你的类被复制，你就应该明确而显示的禁止它。其实lua_State的这个问题非常类似于Effective C++书中的第14个条款中所提到的问题：在资源管理类中小心copying行为。对于这个问题，书中提供了两种解决方案。第一种就是禁止复制。第二种则是对底层资源的“引用计数法”（reference count）。

第一种禁止复制很简单。（关于Uncopyable）

class LuaObject : private Uncopyable
{
public:
    ...
}

第二种则是使用智能指针来封装lua_State，我们可以使用boost的shared_ptr来封装lua_State，即shared_ptr m_L。如何对m_L进行初始化是另一个需要注意的问题，如果使用shared_ptr的常见初始化形式：m_L = shared_ptr( luaL_newstate() )，这样是不对的，因为在这种形式下，当lua_State的计数变为0时，shared_ptr会去调用lua_State的的析构函数，这显然是错误的，对lua_State的释放动作是lua_close而不是删除。事实上，这样编译器也无法通过，如果这么写，会报出“use of undefined type ‘lua_State’”的错误，提示lua_State是一个非完成的类型（incomplete type）。

我们应该为shared_ptr的初始化传入一个删除器（deleter）。很显然，lua_State的deleter是lua_close()函数，这样最终的代码如下。

#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

class LuaObject
{
public:
	LuaObject()
	{
		m_L = shared_ptr( luaL_newstate(), lua_close );
		luaL_openlibs( m_L.get() );
	}

private:
	boost::shared_pt< lua_State > m_L;
};

这样再回到前面拷贝的那个例子，luaObject1和luaObject2共同引用了一个lua_State，但因为使用了shared_ptr，所以只有在lua_State的引用次数变为0时，它的deleter（这里是lua_close）才会被调用，安全了！

在我的项目中，因为没有使用boost库，也没有提供任何智能指针，所以使用禁止复制来保证安全。

Introduction 介绍

最初的互联网是以一个简陋的鼠标点击环境开始的，但如今，互联网上已经到处是各种眼花缭乱的页面，充满着各种丰富的应用程序，有的用来娱乐，有的用来提高生产率，等等等等。用户可以在互联网上完成各式各样的任务，不管是购买商品，还是与全世界的用户实时交互。然而，一个关键的元素却迟迟没有在互联网上打上自己的烙印——3D。

在今天，3D的在线应用主要是游戏和虚拟世界，这些都需要强大的电脑和特殊的软件来支撑。然而，商业，工程企业和其他一些用户同样也需要3D，他们同样也需要3D所带来的真实感和更多细节。用户希望他们能够在浏览器中获得和在PC中一样的体验。并且由于3D技术在电影、游戏和其他各种娱乐行业中的广泛应用，消费者已经对它习以为常。因此，对于互联网上更多且更易于访问的3D内容的需求变得越来越强烈。况且更好的浏览器体验同时也意味着更多潜在的收入。

然而，互联网3D还处于一种很不成熟的状态，因为很难在典型的PC和浏览器上广泛使用这种复杂的技术。事实上，一般浏览器也无法承载复杂的3D内容，更无法提供高帧率或全屏的图形效果。并且，在实时的合作程序和其他应用程序中包含3D让本来已经很繁琐的开发过程会变得更加复杂。

尽管如此，现在是有一些组织在为网络3D技术而努力工作的。他们尝试将浏览器转为一种更为强大的计算平台，以在该平台上获得如PC上一样的体验，例如3D内容的展示。这些工作将会为网络衍生出更多的应用程序，包括产品建模，展示和配置；3D在线会议和工人协作；对于手术或机械过程的模拟；虚拟旅游；增强现实等等。

不管怎样，在互联网3D技术变得可依赖和成为主流之前，仍然有重重的困难需要克服。

3D on the web 网络上的3D

早期的网络是没有图形界面的，直到NCSA（美国国家超计算应用程序中心）在1993年发布了Mosaic，这是首个可以同时展示图片和文字的浏览器。

当前在互联网上，已经有一些为3D服务的技术在使用，他们基本使用同样的方式工作，但是使用不同的文件格式。

VRML和X3D
网络3D开始于1994年，在这一年，VRML组织发布了虚拟现实标记语言（Virtual Reality Markup Language）。然而，VRML从未流行过，因为它限制开发者只可以写3D相关的内容。为了创建完整的引人注目的应用程序，开发者必须能够同时开发3D，2D，视频和音频。在处理器和软件能够支持图形之前，VRML表现还是不错的，因为它能支持图形。但是VRML太慢，并且没有能力渲染复杂高仿真的模型和场景。

在1997年，Web3D联盟推出了X3D，它是一种基于XML的文件格式，同时也是VRML的扩展，以用来表现3D图形。X3D同样也没有流行过。游戏和3D开发人员广泛忽视了X3D，X3D只被极少数的商业工具所支持。

其他方法
3D工业论坛于2003年推出的Universal 3D技术，是一种压缩的3D图形文件格式。然而，它的推崇者也只是推动Universal 3D使其成为了一种主要使用在制造业或建筑业相关应用程序的文件格式。

开源的网络3D标记语言（3DMLW，3D Markup Language for Web）是一种基于XML的文件格式，它用于创建网络上的3D和2D内容。3DMLW由3D Technologies R&D于2009年推出，它可以通过插件工作在大多数流行的浏览器中。

Technical Developments 技术开发

今天的硬件能力能够比过去更好的处理3D。更快的CPU，更快的图形处理器和显卡，以及四处可见的3D图形加速器，这些都为网络3D的出现提供了可能。

JavaScript和HTML 5.0
开发者使用JavaScript语言开发各种网络应用程序。浏览器的 JavaScript引擎性能的提升，使得网络3D成为可能。比如说，IE9中的JavaScript引擎将可以使用宿主机器的图形处理器来快速的处理图形相关的任务。同样的，Mozilla也增强了其Firefox浏览器的JavaScript引擎，他们使用了一种追踪( tracing )技术，该技术通过优化代码的执行方式来提升性能。

JavaScript的访问HTML 5.0的能力可以让开发者更加方便的将视频，音频，3D和2D内容无缝合并到应用程序中。HTML5.0中的画布（canvas）元素同样也会促成互联网3D。该元素使得浏览器可以通过它们的JavaScript引擎，本能（无需插件技术）且动态的渲染位图图片，使得渲染3D变得更加容易。

WebGL
Mozilla 基金会是一个创建和支持开源应用程序的组织，Khronos是一个为并行计算，图形和动态媒体设计标准的联盟。它们俩正在开发WebGL。该技术可以在不需要插件的情况下为网络带来硬件加速的3D图形效果。任何支持Khronos的OpenGL或OpenGL ES规范的浏览器都可以运行WebGL。

跨语言跨平台的OpenGL定义了一组API，以供开发出提供2D和3D图形效果的应用程序。而OpenGL ES（Embedded Systems）规范为从简单元素（或者成为图元，比如线或者多边形）绘制3D场景提供了编程工具。OpenGL ES可以工作在智能手机这样的小型设备上。然而，这些能力不能离开插件的支持。许多用户倾向于不使用插件，因为它们不易安装，且难于排除故障和管理。

WebGL使得浏览无需插件便可渲染3D内容。该技术提供可以让软件通过编程访问PC机3D渲染硬件的API，从而扩展了OpenGL。本质上，WebGL提供了JavaScript应用程序和OpenGL软件库之间的连接，而后者负责访问宿主系统的图形处理器。这可以充分利用硬件的能力来渲染3D内容。

Khronos已经建立了一个WebGL工作组，该工作组将在今年上半年发布 WebGL的第一个release版本。但是程序人员已经开始把WebGL构建到Firefox的开发版和Webkit开源浏览器引擎中，该浏览器引擎被苹果的Safari和Google的Chrome浏览器所使用。

O3D
Google也是 WebGL工作组的成员，但同时Google也开发了一款基于浏览器的3D图形技术，O3D，如下图所示。

图片来源：http://code.google.com/apis/o3d/docs/techoverview.html

O3D是一个基于IE，Firefox，Safari 和Chrome这些浏览器的插件。Google现在正在把该技术构建到Chrome中，并希望未来能够直接构建到其它的浏览器中。O3D可以在Windows，Mac，Linux上运行，它是一套开源的JavaScript API，用于开发互动的3D图形应用程序，比如游戏，广告，或者虚拟产品展示，都运行在一个浏览器里。该API为基于JavaScript的程序提供了接口，使得JavaScript应用程序可以与包含在O3D插件中的O3D核心软件进行通信，从而直接利用计算机的图形硬件。

Google 发言人说O3D是一个保留模式（retained-mode）的技术，因为它只设置场景一次，然后每帧只绘制场景改变的部分。与WebGL这样的立即模式（immediate-mode）技术不同，O3D不会每次都重新绘制整个场景。这提供了更好的性能，但却弱化了开发者的控制能力。

Adobe Flash
Adobe正在将更强的3D能力加入到它所属的Flash浏览器插件中。Adobe是在2008年Flash Player 10的发行版中推出了3D能力。该技术通过加入新的类和方法，从而包含了对于3D效果的支持，尤其可以通过Flash的 ActionScript编程语言在三维空间中设置一个物体的位置。通过这种方法，即便是没有丰富3D经验的开发者也可以通过在2D中设计物体来制作3D内容，并能通过新加入的类和方法修改它们。Flash Player 10.0，现在是beta版，将会为智能手机和其他移动设备带来3D效果。

Standing in the Way 在路上

在3D Web真正成熟之前，它还需要克服重重的障碍。

比如说，插件，在某些情况下，时常会导致浏览器崩溃或者其他的问题。让浏览器能够天生就有渲染3D的能力，并且克服当前3D技术不能和所有的浏览器、操作系统和应用程序兼容的问题，这些都是很大的挑战。另外，缺乏标准化也是一个问题。如果没有标准化，网络将会出现各种不同的互不兼容的格式和技术，这使得开发者为了在不同的浏览器上运行需要创建很多版本的程序。同时，开发网络上的3D内容需要很长的开发时间，并且很少的开发者对该方法很熟悉。

对于上网本和智能手机使用的迅猛增长，这些具有较慢的处理器，意味着更多的人在使用无法运行3D内容的设备。技术硬件能力和网络带宽已经大幅度的提升了，但它们仍然不能满足高度复杂的3D模型的需求。并且网络3D技术的推崇者们并没有为普通用户设计在线3D技术，这是在犯和VRML一样的错误。

Conclusion 结论

WebGL是一个非常有趣的网络3D开发技术，因为它无需插件。一旦WebGL推出，我们将在网络上看到3D内容的迅速增多。然而，3D在10年内是很难成功的，直到迅猛增长的流行上网本和智能手机拥有足够强大的处理器能力来播放数据密集的内容。不过总有一天，3D将在网络上做到像现在视频所做到的一样，网络3D的时代终会到来。