cocos2dx中的class的实现以及C++的__index搜索
2017-01-11 11:40
519 查看
metatable
要理解lua的class,首先要先理解metatable的作用和
__index以及lua调用table里面的函数的时候搜索函数的逻辑:
1、直接当前表里面搜索函数 如果存在,直接调用,不存在继续
2、如果表里面不存在调用的函数,会查找表的metatable的__index
a、如果__index是一个表,则在该表里面查找,回到第一步
b、如果__index是一个函数,则传递要查找的表、函数名字给__index这个函数,并返回函数的返回结果。如果函数返回一个函数则执行该函数,或者直接提示找不到函数,或者返回另外一个表,则又回到第一步在这个表里面查找
伪代码如下:
"index": The indexing access table[key]. function gettable_event (table, key) local h if type(table) == "table" then local v = rawget(table, key) if v ~= nil then return v end h = metatable(table).__index if h == nil then return nil end else h = metatable(table).__index if h == nil then error(···) end end if type(h) == "function" then return (h(table, key)) -- call the handler else return h[key] -- or repeat operation on it end end
cocos2dx-lua
的class实现
下面来看看cocos2dx的lua的class的实现方式
class的声明
function class(classname, ...) local cls = {__cname = classname} --设置类的名字 local supers = {...} for _, super in ipairs(supers) do --遍历第二个参数 local superType = type(super) assert(superType == "nil" or superType == "table" or superType == "function", string.format("class() - create class \"%s\" with invalid super class type \"%s\"", classname, superType)) if superType == "function” then --如果参数是一个函数 则将这个函数设置为类的__create函数 assert(cls.__create == nil, string.format("class() - create class \"%s\" with more than one creating function", classname)); -- if super is function, set it to __create cls.__create = super elseif superType == "table” then --如果是一个表 if super[".isclass"] then --如果是一个c++的对象 -- super is native class assert(cls.__create == nil, string.format("class() - create class \"%s\" with more than one creating function or native class", classname)); cls.__create = function() return super:create() end --__create函数就等于调用c++类的create函数 else -- super is pure lua class cls.__supers = cls.__supers or {} --设置 cls.__supers[#cls.__supers + 1] = super if not cls.super then -- set first super pure lua class as class.super cls.super = super end end else error(string.format("class() - create class \"%s\" with invalid super type", classname), 0) end end cls.__index = cls if not cls.__supers or #cls.__supers == 1 then --如果只有一个父类 则设置metatable为一个表 setmetatable(cls, {__index = cls.super}) else setmetatable(cls, {__index = function(_, key) --如果有多个父类,则设置metatable为一个函数,通过函数查找对应的函数 local supers = cls.__supers for i = 1, #supers do local super = supers[i] if super[key] then return super[key] end end end}) end if not cls.ctor then -- add default constructor cls.ctor = function() end end cls.new = function(...) local instance if cls.__create then instance = cls.__create(...) else instance = {} end setmetatableindex(instance, cls) instance.class = cls instance:ctor(...) return instance end cls.create = function(_, ...) return cls.new(...) end return cls end
函数里面用到的setmetatableindex的实现
local setmetatableindex_ setmetatableindex_ = function(t, index) if type(t) == "userdata" then local peer = tolua.getpeer(t) if not peer then peer = {} tolua.setpeer(t, peer) end setmetatableindex_(peer, index) else local mt = getmetatable(t) if not mt then mt = {} end if not mt.__index then mt.__index = index setmetatable(t, mt) elseif mt.__index ~= index then setmetatableindex_(mt, index) --另外总觉得这一句有问题,不是应该是setmetatableindex(mt.__index, index)吗,如果__index是函数,也应该扩展让其会搜索其metatable或者自身之后,再使用setmetatableindex(mt, index),才会生效,请大神指点迷津 end end end setmetatableindex = setmetatableindex_
这里有两种情况:
对于从C++对象派生的情况,new出来的实际上并不是一个
table而是一个
userdata这个时候其函数从两个地方来:
getmetatable(instance)[funcname]——————>来自于C++类和C++类的父类
这里有一个不解的地方是这个所有的函数都位于metatable中而不是metatable的__index域中,是怎么做到从metatable中查找域而不是metatable的__index域呢。通过输出可以看到每一个metatable中其实是有__index域的,并且是一个函数,不过没有找到实现
tolua.getpeer(instance)[funcname]——————>来自于getpeer返回的table以及其metatable的__index域(递归)
而对于从纯lua对象派生的类,new出来的实例也是一个table
关于C++类搜索key的猜测和测试
对于a的问题,目前猜测是这样,因为metatable的__index是一个函数,所以我猜测是这个函数做了一些特殊操作,因此进行了如下实验:因为我们知道当在一个表或者userdata中找不到某个域的时候,回去__index中查找,如果还是__index是一个函数,则传入__index的参数是这个userdata或者表本身和要查找的域的名字,所以我们考虑设置__index函数为如下的函数:
function myindex(t, key) return getmetatable(t)[key] end
这样就告诉表或者userdata,如果找不到某个函数,就将自己和key传递个__index然后从自己的metatable中查找。实验如下:
local Class1 = {} function Class1:test() print('test') end local Class2 = {} local myIndex = function(t, key) return getmetatable(t)[key] end Class1.__index = myIndex function Class2:new() local o = {} local t = {__index = myIndex} setmetatable(o, t) local t1 = {__index = myIndex} setmetatable(t, t1) setmetatable(t1, Class1) return o end local ta = Class2.new() ta:test()
这段代码输出为test,也就是说可以调用到Class1的test函数
上面的代码Class1就只是
o的
metatable的
metatable的
metatable,和我们cocos2dx返回的userdata的结构类似了
我们来看看这段代码是如何做到的:
首先Class1有一个test函数
然后Class2只是为了给new一个作用域,主要看new的代码
新建一个表o
设置o的metatable为t,t的__index为上面说到的函数
然后设置t的为metable为t1,t1的__index也为上面的函数
最后设置t1的metatable为Class1,Class1的__index也是myIndex
来看调用关系
在ta中查找,找不到,继续
ta中没有通过ta的metatable(t)的__index查找,__index为函数,则将ta和’test’作为参数传递给该函数,该函数通过getmetatable(ta)即(t)查找,t中也没有,继续
t中没有,通过t的metatable(t1)的__index查找,也为函数,将t和’test’作为参数传递给函数,通过getmetatable(t)即(t1)中查找,t1中也没有,继续
t1中没有,通过t1的metatable(Class1)的__index查找,为函数,将t1和’test’作为参数传递给函数,通过getmetatable(t1)即(Class1)查找,找到,所以返回Class1的test函数
说明这种实现方式是可行的,那么再来看看cocos2dx是否是这样实现的。
通过创建一个派生自
cocos2dx的一个
userdata
test,然后尝试输出下面的函数
print(getmetatable(test).__index(test, "visit”))
输出为函数,说明找到了函数,然后我们尝试重载一个函数来看看。
local tmpmetatablefunc = getmetatable getmetatable = function(ta) print(ta) return tmpmetatablefunc(ta) end function ViewBase:setPosition(x, y) print("--------") local tmpindex = getmetatable(self).__index getmetatable(self).__index = function(t1, key) print(t1, key) return tmpindex(t1, key) end local a = getmetatable(self).__index(self, 'setPosition') print(a) local b = getmetatable(self)['setPosition'] print("ttttttttttt") print(a == b) print("callfunction") a(self, x, y) --getmetatable(self)['setPosition'](self, x, y) print("viewbase.setPosition") end
通过__index来获取setPosition函数
当ViewBase重新定一个setPosition函数的时候,如果用这种方式来重载的时候,我发现出现了递归调用,通过上面的测试代码发现是因为通过__index查找到的函数就是我们在这里定义的ViewBase:setPosition本身,而不是我们想调用的其基类的setPosition。由此还可以推断出另外一个事实,那就是tolua++中__index并不是仅仅搜索metatable,还是对tolua.getpeer进行搜索,因为通过上面的Class的定义我们知道ViewBase是放在tolua.getpeer的表的metatale的__index中的。但是这里还没有证明__index会搜索getmetatable的key。
这里我们修改一下函数的名字
local tmpmetatablefunc = getmetatable getmetatable = function(ta) print(ta) return tmpmetatablefunc(ta) end function ViewBase:setPosition1(x, y) print("--------") local tmpindex = getmetatable(self).__index getmetatable(self).__index = function(t1, key) print(t1, key) return tmpindex(t1, key) end local a = getmetatable(self).__index(self, 'setPosition') print(a) local b = getmetatable(self)['setPosition'] print("ttttttttttt") print(a == b) print("callfunction") a(self, x, y) --getmetatable(self)['setPosition'](self, x, y) print("viewbase.setPosition") end
我们重新定义的函数叫setPosition1,这样搜索的时候就不会在tolua.getpeer中找到setPosition了。然后调用setPosition1来设置位置,发现成功了,那就证明
__index函数确实会搜索metatable的域了。
并且综合上面的分析,还可以知道其搜索顺序是先搜索tolua.getpeer中的函数,再搜索metatable,这样就可以做到优先使用我们重新定义的函数而不是积累的函数,做到重定义父类函数的功能。
这里分析了这么多,其实还不如直接去看tolua++的源代码,不过因为时间有限,对lua的c接口还不熟悉,所以仅先通过在lua这边看到的现象进行一些分析知其然,以后再仇视时间区看看tolua++代码和lua代码,之其所以然吧。
对于C++类的派生,创建的时候其实是先从C++创建一个原始的userdata,然后通过设置其getpeer的metatable来扩展其成员函数
其搜索顺序应该是先b后a
如果访问的是C++的原生函数,则是从getmetatable获取到,如果是派生出来的函数,则通过tolua.getpeer的表来得到其类或者父类的域
这个时候其函数和成员变量都来自于
instance[funcname] ——————>instance自身以及其metatable的__index域(递归)
这里是直接创建一个表,然后将其metatable指向其类,然后在访问instance的域的时候就会找到其类或者父类的域了
而如果要调用父类的函数而不是调用自己重载的函数,可以使用如下函数:
function getBaseFunc(data, name) local a if data.super ~= nil then a = data.super[a] end if a == nil then a = getmetatable(data)[a] end return a end
如果调用指定级数的函数
可以直接使用ClassName.func(self, param)
cocos2dx搜索key的实现
cocos2dx中实现了__index函数, 代码如下:tolua_usertype 创建一个metatable且命名,这个metatable就代表了一个C++的
/* Register a usertype * It creates the correspoding metatable in the registry, for both 'type' and 'const type'. * It maps 'const type' as being also a 'type' */ TOLUA_API void tolua_usertype (lua_State* L, const char* type) { char ctype[128] = "const "; strncat(ctype,type,120); /* create both metatables */ if (tolua_newmetatable(L,ctype) && tolua_newmetatable(L,type)) mapsuper(L,type,ctype); /* 'type' is also a 'const type' */ }
在这个函数中调用了
tolua_newmetatable函数
2. tolua_newmetatable 创建metatable
/* Create metatable * Create and register new metatable */ static int tolua_newmetatable (lua_State* L, const char* name) { int r = luaL_newmetatable(L,name); #ifdef LUA_VERSION_NUM /* only lua 5.1 */ if (r) { lua_pushvalue(L, -1); lua_pushstring(L, name); lua_settable(L, LUA_REGISTRYINDEX); /* reg[mt] = type_name */ }; #endif if (r) tolua_classevents(L); /* set meta events */ lua_pop(L,1); return r; }
这个函数中就调用了tolua_classevent来设置metatable的__index函数等metafunction
3. tolua_classevents 设置么他function,其中就包括__index函数
/* Register class events * It expects the metatable on the top of the stack */ TOLUA_API void tolua_classevents (lua_State* L) { lua_pushstring(L,"__index"); lua_pushcfunction(L,class_index_event); lua_rawset(L,-3); lua_pushstring(L,"__newindex"); lua_pushcfunction(L,class_newindex_event); lua_rawset(L,-3); lua_pushstring(L,"__add"); lua_pushcfunction(L,class_add_event); lua_rawset(L,-3); lua_pushstring(L,"__sub"); lua_pushcfunction(L,class_sub_event); lua_rawset(L,-3); lua_pushstring(L,"__mul"); lua_pushcfunction(L,class_mul_event); lua_rawset(L,-3); lua_pushstring(L,"__div"); lua_pushcfunction(L,class_div_event); lua_rawset(L,-3); lua_pushstring(L,"__lt"); lua_pushcfunction(L,class_lt_event); lua_rawset(L,-3); lua_pushstring(L,"__le"); lua_pushcfunction(L,class_le_event); lua_rawset(L,-3); lua_pushstring(L,"__eq"); lua_pushcfunction(L,class_eq_event); lua_rawset(L,-3); lua_pushstring(L,"__call"); lua_pushcfunction(L,class_call_event); lua_rawset(L,-3); lua_pushstring(L,"__gc"); lua_pushstring(L, "tolua_gc_event"); lua_rawget(L, LUA_REGISTRYINDEX); /*lua_pushcfunction(L,class_gc_event);*/ lua_rawset(L,-3); }
class_index_event即为真正的搜索key的逻辑了
/* Class index function * If the object is a userdata (ie, an object), it searches the field in * the alternative table stored in the corresponding "ubox" table. */ static int class_index_event (lua_State* L) { int t = lua_type(L,1); if (t == LUA_TUSERDATA) //如果是userdata { /* Access alternative table */ #ifdef LUA_VERSION_NUM /* new macro on version 5.1 */ //从peer里面搜索key lua_getfenv(L,1); if (!lua_rawequal(L, -1, TOLUA_NOPEER)) { lua_pushvalue(L, 2); /* key */ lua_gettable(L, -2); /* on lua 5.1, we trade the "tolua_peers" lookup for a gettable call */ if (!lua_isnil(L, -1)) //如果搜索到key,则直接返回 return 1; }; #else lua_pushstring(L,"tolua_peers"); lua_rawget(L,LUA_REGISTRYINDEX); /* stack: obj key ubox */ lua_pushvalue(L,1); lua_rawget(L,-2); /* stack: obj key ubox ubox[u] */ if (lua_istable(L,-1)) { lua_pushvalue(L,2); /* key */ lua_rawget(L,-2); /* stack: obj key ubox ubox[u] value */ if (!lua_isnil(L,-1)) return 1; } #endif lua_settop(L,2); /* stack: obj key */ /* Try metatables */ lua_pushvalue(L,1); /* stack: obj key obj */ while (lua_getmetatable(L,-1)) { /* stack: obj key obj mt */ lua_remove(L,-2); /* stack: obj key mt */ if (lua_isnumber(L,2)) /* check if key is a numeric value */ { /* try operator[] */ lua_pushstring(L,".geti"); lua_rawget(L,-2); /* stack: obj key mt func */ if (lua_isfunction(L,-1)) { lua_pushvalue(L,1); lua_pushvalue(L,2); lua_call(L,2,1); return 1; } } else { //在metatable中搜索 lua_pushvalue(L,2); /* stack: obj key mt key */ lua_rawget(L,-2); /* stack: obj key mt value */ if (!lua_isnil(L,-1)) return 1; else lua_pop(L,1); /* try C/C++ variable */ lua_pushstring(L,".get"); //c++的变量保存在".get"中 lua_rawget(L,-2); /* stack: obj key mt tget */ if (lua_istable(L,-1)) { lua_pushvalue(L,2); lua_rawget(L,-2); /* stack: obj key mt value */ if (lua_iscfunction(L,-1)) { lua_pushvalue(L,1); lua_pushvalue(L,2); lua_call(L,2,1); return 1; } else if (lua_istable(L,-1)) { /* deal with array: create table to be returned and cache it in ubox */ void* u = *((void**)lua_touserdata(L,1)); lua_newtable(L); /* stack: obj key mt value table */ lua_pushstring(L,".self"); lua_pushlightuserdata(L,u); lua_rawset(L,-3); /* store usertype in ".self" */ lua_insert(L,-2); /* stack: obj key mt table value */ lua_setmetatable(L,-2); /* set stored value as metatable */ lua_pushvalue(L,-1); /* stack: obj key met table table */ lua_pushvalue(L,2); /* stack: obj key mt table table key */ lua_insert(L,-2); /* stack: obj key mt table key table */ storeatubox(L,1); /* stack: obj key mt table */ return 1; } } } lua_settop(L,3); } lua_pushnil(L); return 1; } else if (t== LUA_TTABLE) //如果是表 { lua_pushvalue(L,1); class_table_get_index(L); return 1; } lua_pushnil(L); return 1; }
class_table_get_index 函数
static int class_table_get_index (lua_State* L) { // stack: obj key ... obj while (lua_getmetatable(L,-1)) { /* stack: obj key obj mt */ lua_remove(L,-2); /* stack: ... mt */ lua_pushvalue(L,2); /* stack: ... mt key */ lua_rawget(L,-2); /* stack: ... mt value */ if (!lua_isnil(L,-1)) { return 1; } else { lua_pop(L,1); } /* try C/C++ variable */ lua_pushstring(L,".get"); lua_rawget(L,-2); /* stack: obj key ... mt tget */ if (lua_istable(L,-1)) { lua_pushvalue(L,2); /* stack: obj key ... mt tget key */ lua_rawget(L,-2); /* stack: obj key ... mt tget value */ if (lua_iscfunction(L,-1)) { lua_call(L,0,1); return 1; } else if (lua_istable(L,-1)) { return 1; } lua_pop(L, 2); } } lua_pushnil(L); return 1; }
相关文章推荐
- cocos2dx 3.15 视频播放实现 lua 以及c++ 版本VideoPlayer的使用注意 与详细示例
- 实现支持逻辑搜索/单词搜索/词组搜索+支持OR/AND关键字的VBS CLASS!
- 实现支持逻辑搜索/单词搜索/词组搜索+支持OR/AND关键字的VBS CLASS
- 简单谈谈 C/C++ 递归的思想,实现,以及和循环的关系。
- 初学者看过来:简单谈谈 C/C++ 递归的思想,实现,以及和循环的关系
- jquery 关键字“拖曳搜索”之“拖曳”以及 图片“提示自适应放大”效果 的实现
- 用C实现C++ Class
- C++ 二叉树的实现以及指针使用注意事项
- C#的锯齿数组以及C++实现
- 在C中用struct实现C++中class的函数声明和定义
- C与C++中struct的区别,以及C++中struct与Class的区别
- 初学者看过来:简单谈谈 C/C++ 递归的思想,实现,以及和循环的关系。
- 在C中用struct实现C++中class的函数声明和定义
- 如何用SQL语句实现精确搜索以及模糊搜索
- C++链表实现堆栈:LinkList:Build a linklist using C++ class Stack
- 如何用SQL语句实现精确搜索以及模糊搜索
- 如何用SQL语句实现精确搜索以及模糊搜索
- 链队列的C++ 实现以及循环队列
- 关键字“拖曳搜索”之“拖曳”以及 图片“提示自适应放大”效果 的实现
- C++中的虚继承,以及利用虚继承实现的sealed类