浅析C++绑定到Lua的方法

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

注：原文也在公司内部论坛上发了

概述

尽管将C++对象绑定到Lua已经有tolua++(Cocos2d-x 3.0用的就是这个)、LuaBridge(我们游戏client对这个库进行了改进)和luabind等各种库能够直接使用了（lua-users.org上有对各种语言绑定到lua库的汇总），但弄清楚C++对象绑定到Lua的常见方法，不但有助于更深的了解Lua的机制，还能够方便改动第三方库以满足实际项目需求。

本文通过分析第三方库Lunar（我们游戏服务端用的是Luna，Lunar是Luna添加版。但仍然足够简洁）的实现，来理解C++对象绑定到Lua的通常方法。Lunar的測试代码放在我的 github 上。

Lunar实现的功能以及原理

Lunar实现很简洁，同一时候实现了C++绑定到Lua主要功能。使用Lunar至少能够做到下面几点：

1、在脚本中，能够使用注冊过的类创建C++对象，此类C++对象，由Lua控制何时释放。

2、在C++创建的对象，能够压入栈中，供脚本使用这个对象，而且提供一个可选參数。来决定这个对象是由C++控制释放，还是Lua控制释放。

3、脚本中的C++类对象。能够调用注冊过的类成员函数。

4、在C++中，能够获取在脚本中创建的对象。而且在C++中能够调用这个对象的成员函数。

5、能够在脚本中定义对象的成员函数，而且能在C++中调用这些用脚本实现的成员函数。

在脚本中创建C++对象，实质返回给脚本是一个userdata类型的值ud。ud中保存一个指针，该指针指向所创建的C++对象。这时候Lua控制对象何时释放，即在Lua在回收userdata时，同一时候利用userdata的元表__gc字段来回收动态分配的对象，这时候就不须要C++释放内存了。注意这里返回给脚本不能是lightuserdata。由于lightuserdata实质上仅仅是一个指针。不受垃圾回收收集器的管理，而且它也没有元表。

在脚本中创建的对象是由Lua来维护对象的生命周期。

在Lunar中还能够使用Lunar<T>::push(lua_State *L, T *obj, bool gc=false)向栈中压入对象供脚本使用，当中第三个參数能够决定创建的对象是由C++控制释放。还是Lua控制释放。其原理是在把要传递给Lua的对象obj压入栈时，它首先利用对象地址在lookup表中查找（lookup是一个mode为"v"的weak table。保存全部在脚本中使用的对象。该表的key是对象地址。value是对象相应的userdata），若不在lookup中。则会创建一个新的userdata。并把它保存在lookup中，若第三个參数为false，即由C++控制对象释放。还会把上面的userdata保存在一个nottrash表中，nottrash是一个mode为"k"的weak
table，保存全部不会随userdata回收其对应对象也释放的userdata，该表key为userdata。value为true。

这样处理后，在Lua回收userdata时，首先检測userdata是否在nottrash中。若不在。则删除userdata所指向对象，否则须要C++自己释放所创建的对象。

在调用Lunar<T>::Register(lua_State *L)向脚本注冊类时，会创建两个表，一个是methods表。该表的key为函数名，value为函数地址（函数能够是C++中定义类的方法，也能够在Lua中定义函数），在Lua中调用的对象方法。都保存在该表中；还有一个是metatable表，做为userdata的元表，该metatable表保存了上面的lookup表和nottrash表。而且设置了metatable.__metatable = methods，这样在脚本中就隐藏了metatable表，也就是说在Lua中，调用getmetatable(userdata)得到的是methods表，而不是metatable表，在脚本中，给对象加入成员方法也是会保存在methods表中。

Lunar源代码分析

以下逐行分析了Luanr的实现，在附件中是Lunar的測试代码。例如以下：

001 extern "C" {

002 #include "lua.h"

003 #include "lauxlib.h"

004 }

005

006 #define LUNAR_DECLARE_METHOD(Class, Name) {#Name, &Class::Name}

007

008 template < typename T> class Lunar {

009 public :

010

011 //C++能够向Lua注冊的函数类型

012 typedef int (T::*mfp)(lua_State *L);

013

014 //向Lua中注冊的函数名字以及相应的函数地址

015 typedef struct { const char *name; mfp mfunc; } RegType;

016

017 //用来注冊C++定义的类供Lua使用

018 static void Register(lua_State *L) {

019 //创建method table，该table key为函数名，

020 //value为函数地址（函数能够是C++中定义类的方法，也能够在Lua中定义函数）

021 //在Lua中，以table的key为函数名。调用对应的方法。

022 lua_newtable(L);

023 int methods = lua_gettop(L);

024

025 //创建userdata的元表

026 luaL_newmetatable(L, T::className);

027 int metatable = lua_gettop(L);

028

029 //把method table注冊到全局表中，这样在Lua中能够直接使用该table。

030 //这样能够在这个table中添加Lua实现的函数

031 lua_pushvalue(L, methods);

032 set(L, LUA_GLOBALSINDEX, T::className);

033

034 //隐藏userdata的实质的元表，也就是说在Lua中

035 //调用getmetatable(userdata)得到的是methods table。而不是metatable table

036 lua_pushvalue(L, methods);

037 set(L, metatable, "__metatable" );

038

039 //设置metatable table的元方法

040 lua_pushvalue(L, methods);

041 set(L, metatable, "__index" );

042

043 lua_pushcfunction(L, tostring_T);

044 set(L, metatable, "__tostring" );

045

046 //设置__gc元方法。这样方便在Lua回收userdata时，

047 //能够做一些其它操作。比方释放其对应的对象

048 lua_pushcfunction(L, gc_T);

049 set(L, metatable, "__gc" );

050

051 lua_newtable(L); //创建methods的元表mt

052 lua_pushcfunction(L, new_T);

053 lua_pushvalue(L, -1); // 把new_T再次压入栈顶

054 set(L, methods, "new" ); // 把new_T函数增加到methods中。这样脚本可通过调用T:new()来创建C++对象

055 set(L, -3, "__call" ); // mt.__call = mt，这样脚本能够通过调用T()来创建C++对象

056 lua_setmetatable(L, methods); //设置methods的元表为mt

057

058 //把类T中的方法保存到method table中，供Lua脚本使用

059 for (RegType *l = T::methods; l->name; l++) {

060 lua_pushstring(L, l->name);

061 lua_pushlightuserdata(L, ( void *)l); //以注冊函数在数组的位置作为cclosure的upvalue

062 lua_pushcclosure(L, thunk, 1); //在Lua调用的类方法，调用的都是c closure thunk，thunk通过upvalue获取实质调用的函数地址

063 lua_settable(L, methods);

064 }

065

066 lua_pop(L, 2); //弹出methods和metatable table。保证Register调用后。栈的空间大小不变

067 }

068

069 //调用保存在method table中的函数

070 //在调用call之前。须要向栈中压入userdata和參数。

071 //并把最后的调用结果压入栈中，參数method传入要调用的函数名

072 static int call(lua_State *L, const char *method,

073 int nargs=0, int nresults=LUA_MULTRET, int errfunc=0)

074 {

075 int base = lua_gettop(L) - nargs; //获取userdata在栈中的索引

076 if (!luaL_checkudata(L, base, T::className)) {

077 //假设用错误的类型调用对应的方法。则从栈中弹出userdata和參数

078 //而且压入对应的错误信息

079 lua_settop(L, base-1);

080 lua_pushfstring(L, "not a valid %s userdata" , T::className);

081 return -1;

082 }

083

084 lua_pushstring(L, method); //压入方法名，通过该名字在userdata method table中获取实质要调用的c closure

085

086 //获取相应的函数地址。其流程是从userdata的元表metatable查找，

087 //而metatable.__index=methods，在methods中通过方法名，获取对应的方法

088 lua_gettable(L, base);

089 if (lua_isnil(L, -1)) { //若不存在对应的方法

090 lua_settop(L, base-1);

091 lua_pushfstring(L, "%s missing method '%s'" , T::className, method);

092 return -1;

093 }

094 lua_insert(L, base); // 把方法移到userdata和args以下

095

096 int status = lua_pcall(L, 1+nargs, nresults, errfunc); // 调用方法

097 if (status) {

098 const char *msg = lua_tostring(L, -1);

099 if (msg == NULL) msg = "(error with no message)" ;

100 lua_pushfstring(L, "%s:%s status = %d\n%s" ,

101 T::className, method, status, msg);

102 lua_remove(L, base); // remove old message

103 return -1;

104 }

105 return lua_gettop(L) - base + 1; // 调用的方法。返回值的个数

106 }

107

108 //向栈中压入userdata，该userdata包括一个指针，该指针指向一个类型为T的对象

109 //參数obj为指向对象的指针，參数gc默觉得false，即Lua在回收userdata时，不会主动是释放obj相应的对象，此时应用程序负责相应对象释放

110 //若为true，则Lua在回收userdata时。会释放对应的对象

111 static int push(lua_State *L, T *obj, bool gc= false ) {

112 if (!obj) { lua_pushnil(L); return 0; }

113 luaL_getmetatable(L, T::className); //在注冊表中获取类名的相应的table mt，以作为以下userdata的元表

114 if (lua_isnil(L, -1)) luaL_error(L, "%s missing metatable" , T::className);

115 int mt = lua_gettop(L);

116

117 //设置mt["userdata"] = lookup。并向栈顶压入lookup，lookup是一个mode为"v"的weak table，保存全部类对象相应的userdata

118 //key是对象地址，value是userdata

119 subtable(L, mt, "userdata" , "v" );

120 userdataType *ud =

121 static_cast <userdataType*>(pushuserdata(L, obj, sizeof (userdataType))); //向栈顶压入一个userdata

122 if (ud) {

123 ud->pT = obj; //把对象的地址obj保存到userdata中

124 lua_pushvalue(L, mt); //压入注冊表中类名相应的table mt

125 lua_setmetatable(L, -2); //设置userdata的元表

126 if (gc == false ) {

127 //gc为false。Lua在回收userdata时，不会主动是释放obj相应的对象，此时应用程序负责相应对象释放

128 lua_checkstack(L, 3);

129

130 //mt["do not trash"] = nottrash。nottrash是一个mode为"k"的weak table，保存全部不会随userdata回收其对应对象也释放的userdata

131 //key是userdata，value是true。向栈顶压入nottrash

132 subtable(L, mt, "do not trash" , "k" );

133 lua_pushvalue(L, -2); //再次压入userdata

134 lua_pushboolean(L, 1);

135 lua_settable(L, -3); //nottrash[userdata] = true

136 lua_pop(L, 1); //把nottrash从栈中弹出

137 }

138 }

139 lua_replace(L, mt); //把索引mt出元表值替换为userdata

140 lua_settop(L, mt); //设置栈的大小。即通过调用push()调用，栈顶元素为userdata，该userdata包括指向对象的指针

141 return mt; //返回userdata在栈中的索引

142 }

143

144 //检測索引narg处的值是否为对应的userdata，若是则返回一个指针。该指针指向类型T的对象

145 static T *check(lua_State *L, int narg) {

146 userdataType *ud =

147 static_cast <userdataType*>(luaL_checkudata(L, narg, T::className));

148 if (!ud) {

149 luaL_typerror(L, narg, T::className);

150 return NULL;

151 }

152 return ud->pT;

153 }

154

155 private :

156

157 typedef struct { T *pT; } userdataType;

158

159 Lunar(); //隐藏默认的构造函数

160

161 //Lua中调用类的成员函数，都是通过调用该函数，然后使用userdataType的upvalue来调用实质的成员函数

162 static int thunk(lua_State *L) {

163 //此时栈中元素是userdata和參数

164 T *obj = check(L, 1); //检測是否是对应的userdata，若是，返回指向T对象的指针

165 lua_remove(L, 1); //从栈中删除userdata。以便成员函数的參数的索引从1開始

166 //利用upvalue获取对应的成员函数

167 RegType *l = static_cast <RegType*>(lua_touserdata(L, lua_upvalueindex(1)));

168 return (obj->*(l->mfunc))(L); //调用实质的成员函数

169 }

170

171 //创建一个新的对象T。在脚本中调用T()或T:new()，实质调用的都是该函数

172 //调用后，栈顶元素为userdata，该userdata包括指向对象的指针

173 static int new_T(lua_State *L) {

174 lua_remove(L, 1); // 要求在脚本中使用T:new()，而不能是T.new()

175 T *obj = new T(L); // 调用类T的构造函数

176 push(L, obj, true ); // 传入true，表明Lua回收userdata时，对应的对象也会删除

177 return 1;

178 }

179

180 //Lua在回收userdata时，对应的也会调用该函数

181 //依据userdata是否保存在nottrash（即mt["do not trash"]，mt为注冊表中T:classname相应的table）中来决定

182 //是否释放对应的对象，若在，则不释放对应的对象，须要应用程序自己删除，否则删除对应的对象

183 static int gc_T(lua_State *L) {

184 if (luaL_getmetafield(L, 1, "do not trash" )) {

185 lua_pushvalue(L, 1); //再次压入userdata

186 lua_gettable(L, -2); //向栈中压入nottrash[userdata]

187 if (!lua_isnil(L, -1)) return 0; //在nottrash中，不删除对应的对象

188 }

189 userdataType *ud = static_cast <userdataType*>(lua_touserdata(L, 1));

190 T *obj = ud->pT;

191 if (obj) delete obj; //删除对应的对象

192 return 0;

193 }

194

195 //在Lua中调用tostring(object)时，会调用该函数

196 static int tostring_T (lua_State *L) {

197 char buff[32];

198 userdataType *ud = static_cast <userdataType*>(lua_touserdata(L, 1));

199 T *obj = ud->pT;

200 sprintf (buff, "%p" , ( void *)obj);

201 lua_pushfstring(L, "%s (%s)" , T::className, buff);

202

203 return 1;

204 }

205

206 //设置t[key]=value，t是索引为table_index相应的值，value为栈顶元素

207 static void set(lua_State *L, int table_index, const char *key) {

208 lua_pushstring(L, key);

209 lua_insert(L, -2); //交换key和value

210 lua_settable(L, table_index);

211 }

212

213 //在栈顶压入一个模式为mode的weak table

214 static void weaktable(lua_State *L, const char *mode) {

215 lua_newtable(L);

216 lua_pushvalue(L, -1);

217 lua_setmetatable(L, -2); //创建的weak table以自身作为元表

218 lua_pushliteral(L, "__mode" );

219 lua_pushstring(L, mode);

220 lua_settable(L, -3); // metatable.__mode = mode

221 }

222

223 //该函数向栈中压入值t[name]。t是给定索引的tindex的值，

224 //若原来t[name]值不存在，则创建一个模式为mode的weak table wt，而且赋值t[name] = wt

225 //最后栈顶中压入这个weak table


             
             
             
             
             
              
              
              
              
              
              
              
              
              
              
             
             
              posted @ 2017-06-25 19:07 yxysuanfa 阅读(...) 评论(...)  编辑 收藏
             
             
              var allowComments=true,cb_blogId=348828,cb_entryId=7077574,cb_blogApp=currentBlogApp,cb_blogUserGuid='4ed8aa7c-ad21-e711-9fc1-ac853d9f53cc',cb_entryCreatedDate='2017/6/25 19:07:00';loadViewCount(cb_entryId);var cb_postType=1;var isMarkdown=false;
             
             
              end: topics 文章、评论容器
             
             
             
             
              var commentManager = new blogCommentManager();commentManager.renderComments(0);
             
             
              
              
              
               刷新评论刷新页面返回顶部
              
              
              
              
              
              
              
              
              
              
               var googletag = googletag || {};
               

               googletag.cmd = googletag.cmd || [];
              
              
               googletag.cmd.push(function() {
               

               googletag.defineSlot('/1090369/C1', [300, 250], 'div-gpt-ad-1546353474406-0').addService(googletag.pubads());
               

               googletag.defineSlot('/1090369/C2', [468, 60], 'div-gpt-ad-1539008685004-0').addService(googletag.pubads());
               

               googletag.pubads().enableSingleRequest();
               

               googletag.enableServices();
               

               });
              
              
               
               
              
              
              
              
               
               
              
              
              
              
              
              
               if(enablePostBottom()) {
               

               codeHighlight();
               

               fixPostBody();
               

               setTimeout(function () { incrementViewCount(cb_entryId); }, 50);
               

               deliverT2();
               

               deliverC1();
               

               deliverC2();
               

               loadNewsAndKb();
               

               loadBlogSignature();
               

               LoadPostInfoBlock(cb_blogId, cb_entryId, cb_blogApp, cb_blogUserGuid);
               

               GetPrevNextPost(cb_entryId, cb_blogId, cb_entryCreatedDate, cb_postType);
               

               loadOptUnderPost();
               

               GetHistoryToday(cb_blogId, cb_blogApp, cb_entryCreatedDate);
               

               }