起因
网路上已经有很多关于lua面向对象开发的文章，为什么我要自己写一篇呢？
一切都是因cocos2d-x 3.2的lua绑定而起。我们的新项目打算用lua进行开发，一直在跟进quick-x项目，从独立、第三方，到现在的被触控收编。cocos2d-x 3.2是最新的稳定版，把quick-x的很多好东西吸纳进来。与其说吸纳，不如说是直接把源代码拿过来了。所以，现在cocos2d-x 3.2直接就支持lua的面向对象开发，提供了原来只有quick-x才有的class等方法来方便的创建对象以及做继承。
既然cocos2d-x官方都认为quick-x的东西很好，我也不得不研究一下这套针对lua开发的创建类和继承的方法。不研究不要紧，一研究吓一跳。备受关注的quick-x，把自己宣传的那么好，那么便捷（我刚开始研究quick-x的时候，用它写过一个项目，提供的接口确实很便捷，大大提高了开发效率，但是没有研究实现细节），没想到最最底层，最最基础的部分，创建类、类继承的方案却如此业余，简直是一个刚学lua两三天的“高手”写出来的。说刚学两三天，是因为，从这个方案可以看出，完全没有理解lua语言的真谛，没有做到thinking in lua，而“高手”并不是贬义，一般人真的做不出这样的设计，写不出这样的代码。
分析
当然，也不是说这份代码一无是处（下个章节会详细分析），我这里先说说这份代码的优点和缺陷，仅代表个人意见，希望能引起共鸣。
优点
- 分解了创建实例(cls.__create)和构造函数的方法(instance:ctor)，这样做的好处很明显，让混沌的思路清晰起来，并且“支持”从function继承，这也是支持从cpp对象继承的基础。
- 创造了类与类的实例之间的区别
- 类：cls.class == nil
- 类的实例：instance.class ~= nil
- 支持从cpp、lua的table继承，也支持创造新的类
- 支持默认构造函数
- 当创建新的类时，有一个什么都不做的构造函数
- 当lua的table继承时，可以调用父类的构造函数
缺陷
- 不支持多继承，这对于从cpp开发转过来的开发人员来说，可能是最大的问题，因为lua的特性其实是可以支持多继承的
- 没有充分利用lua的特性（下面的review详细展开讲）
- 从lua的table继承时，不需要做clone，clone会失去很多好处，并且带来额外的内存开销
- 构造函数在继承过程中存在设计缺陷（下面的review会展开讲）
小结
所以总体上来看，还是优点多于缺点的。但是对于用惯了多继承（即使是不支持多继承的语言，比如Java、C#也是支持多接口实现的）的我来说，这点实在不可忍，所以不得不自己写了一套继承机制，为了避免这篇文章太长，将在下一篇文章中公开。
代码review
下面是重头戏了，让我们来看看class函数的代码。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
--Create an class. function class(classname, super) -- Part 1 -- local superType = type(super) local cls if superType ~= "function" and superType ~= "table" then superType = nil super = nil end -- End of Part 1 -- if superType == "function" or (super and super.__ctype == 1) then -- Part 2 -- -- inherited from native C++ Object cls = {} if superType == "table" then -- copy fields from super for k,v in pairs(super) do cls[k] = v end cls.__create = super.__create cls.super = super else cls.__create = super end cls.ctor = function() end cls.__cname = classname cls.__ctype = 1 function cls.new(...) local instance = cls.__create(...) -- copy fields from class to native object for k,v in pairs(cls) do instance[k] = v end instance.class = cls instance:ctor(...) return instance end -- End of Part 2 -- else -- Part 3 -- -- inherited from Lua Object if super then cls = clone(super) cls.super = super else cls = {ctor = function() end} end cls.__cname = classname cls.__ctype = 2 -- lua cls.__index = cls function cls.new(...) local instance = setmetatable({}, cls) instance.class = cls instance:ctor(...) return instance end -- End of Part 3 -- end return cls end |
为了让没有使用过这个函数的读者也能读懂，先说一下函数的用法吧
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
--- Sample1: 创建新的类 -- 创建一个名为ClassA的类 local ClassA = class("ClassA") -- 创建ClassA类的实例 local a = ClassA.new() -- ClassA的构造函数 function ClassA:ctor() self.name = "a" end local aa = ClassA.new() print(aa.name) -- 输出：a --- Sample2: 从lua的table继承 -- 创建一个名为ClassB的类，ClassB继承于ClassA local ClassB = class("ClassB", ClassA) -- 创建ClassB类的实例 local b = ClassB.new() --- Sample3: 从cpp对象（在lua中是userdata）继承 -- 创建一个名为ClassC的类，ClassC继承于cc.Scene local ClassC = class("ClassC", function() return cc.Scene:create() end) -- 创建ClassC类的实例 local c = ClassC.new() |
总体上看，这个函数可以分为3个部分（我已经在代码中用注释标明）。
- 局部变量声明以及参数类型检查
- 从cpp类继承
- 从lua的table继承
局部变量声明以及参数类型检查
|
1 2 3 4 5 6 7 |
local superType = type(super) -- 父类的类型，用于后面决定要进入哪个分支 local cls -- 这将是最后的返回值 -- 父类的类型必须是function或者table，如果都不是，就当做super传的是nil，也就是说当做创建新类来处理 if superType ~= "function" and superType ~= "table" then superType = nil super = nil end |
从cpp类继承
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
-- inherited from native C++ Object cls = {} -- 初始化cls -- 父类是从cpp的类继承的 if superType == "table" then -- 从父类拷贝所有的元素，我认为这里是有问题的，详见下面的问题1 for k,v in pairs(super) do cls[k] = v end cls.__create = super.__create -- 我想这个只是用来提醒自己，其实这个赋值已经包含在上面的for循环中了 cls.super = super else -- 传进来的super是function，__create用来创建类的实例 cls.__create = super end cls.ctor = function() end -- 默认构造函数，我认为这里有2个问题的，详见下面的问题2和问题3 cls.__cname = classname -- 类名 cls.__ctype = 1 -- 类的类型，代表是从cpp的类（userdata）继承的 -- 类的new方法，同问题3 function cls.new(...) local instance = cls.__create(...) -- 创建类的实例 -- 拷贝所有的元素到实例中，我认为这里也是有问题的，详见下面的问题4 for k,v in pairs(cls) do instance[k] = v end instance.class = cls -- 对实例的class进行赋值，可以从实例找到cls instance:ctor(...) -- 调用构造函数 return instance end |
问题1：从父类做深度拷贝
这里的super已经是拷贝过cpp类（userdata）的所有元素，已经是个lua的table了，我认为这里可以完全当做从lua的table继承来处理，而没必要再做一次深度拷贝。
问题2：默认的空构造函数
先理一下代码走到这里的前提
- super是function
- 或者super是从cpp类继承的table
你想到了什么？对，如果super是从cpp类继承的table，那么这里的默认构造函数就屏蔽了父类的构造函数。当然，在构造函数ctor里面有办法调到父类的构造函数的，可以这么做self.class.super.ctor(self)。但是回过头来看第一个前提，super是function的时候，super是没有被赋值到self.class.super的，所以现在要调用父类的构造函数的话，莫非还要判断一下？
问题3：不能被重复利用的代码
由于lua的随意性，很容易同一份代码被“写了多次”，又由于lua的函数是第一类对象，也就是说函数是可以被动态创建的。那么所有代码中，被我标记了问题3的地方，这些地方的函数，虽然看起来就一份代码，但是被创建出来以后却全是不同的实例。试想一下，每一个新创建的类型（不是类的实例），都包含了一个冗余的代码块，得有多大的代价？（实际开销可能并不大，但总觉得是个浪费。）
问题4：创建实例时的深度拷贝
这是在干嘛呢？拷贝那么多遍干嘛？都已经拷贝一遍到cls里面了，再拷贝一遍到instance干嘛呢？完全没有thinking in lua嘛！这里只需要setmetatable就可以了呀。
从lua的table继承
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
-- inherited from Lua Object if super then cls = clone(super) -- 从父类做深度拷贝，又来了，问题5 cls.super = super -- 标记父类 else cls = {ctor = function() end} -- 父类为空时，创建默认构造函数，同上面的问题3 end cls.__cname = classname -- 保存类名 cls.__ctype = 2 -- lua -- 标记这是个lua继承来的类 cls.__index = cls -- 为setmetatable做准备 -- 类的new方法，同上面的问题3 function cls.new(...) local instance = setmetatable({}, cls) -- “正统的”lua类继承来了 instance.class = cls -- 对实例的class进行赋值，可以从实例找到cls instance:ctor(...) -- 调用构造函数 return instance end |
问题5：从父类做深度拷贝
刚刚从userdata做深度还是可以理解的，但是现在是从lua的table做继承呀，放着setmetatable不用，又clone干嘛呀？
总结
很多观点可能会有人认为偏颇，因为大多是深度拷贝的问题，而深度拷贝的时候，对于table、function、userdata等数据来说，也只是拷贝一个引用，并没有太大的代价。但我始终固执地认为，既然要用lua，就应该用lua的思维来解决问题，特别是底层的部分，而且底层的部分，对于内存和执行效率的考虑应该更深入，更全面一些。
不过至少大家可以达成共识，最大的问题就是问题2。
最后，放出我自己写的Oop库来解决上面的问题，并且有更多惊喜等着你去发现。