Solmyr 的小品文系列之三之四：对象计数

台下的座位已经坐满了，除了 Solmyr 的位子。zero 手足无措的望着那唯一的空位，开始第一百次的哀叹为什么自己会落到这样一个尴尬的位置。仅仅几分钟前，一切都还很正常，直到 ………… 

………… 

主持人：“下一个议程，题为‘对象计数’的 C++ 编程技术讲座，主讲人是zero。” 

zero： “什 …… 什么？！等一等，这个讲座不是应该由 Solmyr 主讲吗？！” 

主持人：“嗯，原定是由 Solmyr 来讲，不过临时有要事出去了，离开之前他指定你顶替。他没有告诉你吗？” 

zero： “他压根没有和我提过！我 …… 我什么准备也没做！这怎么行？别开玩笑了？！” 

主持人：“你不用谦虚，Solmyr 临走前对我说过你完全能够胜任这个议题。啊对了，这里有一张他留给你的条子。” 

zero 打开条子，但见上面写到：“《50 诫》（注：指《More Effective C++ 2/e》一书）看得怎么样了？如果你认真看过，就没问题。如果你敢拒绝或者出了岔子，嘿嘿 ……” 

………… 

“唉！”，zero 认命的叹了口气，“面对现实，硬着头皮上吧！”他决定就讲最简单的那部分，反正把这个场面搪塞过去就行了。他望着白板上“对象计数”四个大字，开口说到： “今天 …… 这个 …… 今天讨论的议题是‘对象计数’。所谓对象计数 …… 啊 …… 就是对计算某个类有多少个对象”。 

开场白糟透了，zero 觉得还是尽快转入实际的东西比较好。 

“对于这个问题 …… 最简单的做法是在需要计数的类中添加一个静态变量，保存当前的对象个数，并利用构造函数和析构函数增减它的值，象这样：” 

class Wedget 
{ 
public: 
    Wedget(){ m_count++; }; 
    ~Wedget(){ m_count--; }; 

    int GetCout(){ return m_count; }; 

private: 
    static int m_count; 
}; 

int Wedget::m_count = 0; 

说着说着，zero 发现这件事似乎其实没有那么困难，反而觉得渐渐进入了状态，话也流利起来： 

“上述做法很容易理解：一个类中的 static 类型的成员变量是被这个类的所有对象所共享的。当该类新增一个对象时，构造函数会保证计数值加一，销毁一个对象时，析构函数会保证计数值减一。这里唯一需 要注意的只有一点：如果 Wedget 派生自一个基类，那么基类的析构函数一定得声明为虚函数。为什么呢？因为我们时常会用基类的指针操作派生类的对象，这是所谓“多态”的做法，面向对象程序 设计的基本技术之一。也就是说下面这一类的代码会很常见：” 

class Base 
…… 

class Wedget : public Base 
…… 

Base* pb = new Wedget; // 基类指针指向派生类对象 
…… 

delete pb; 

“但如果 Base 的析构函数没有声明为虚函数，那么当执行到 delete pb 这一句的时候，编译器只知道 pb 是一个 Base* 类型的指针，只会去调用 Base 类的析构函数，这样一来，明明销毁了一个 Wedget 类的对象，Wedget 类的析构函数却没有调用，计数值就会出现错误。所以必须将 Base 的析构函数声明为虚，告诉编译器去判断这个对象的实际类型，保证 Wedget 类的析构函数被调用。” 

zero 顿了一顿，续道： 

“顺便指出一下，这一点是 C++ 面向对象程序设计的一个普遍原则。” 

zero 环视了一眼台下，发现所有人都听的很认真，有些人还露出了领悟的表情，这使得他信心大增，决定接着讲下去： 

“某种意义上说，现在我们已经解决了‘对象计数’这个问题。但是事情还没完 —— 我们可能有许多类都需要对对象计数，如果我们对每个类都象上面这样手工的添这些代码进去，那么这个工作既枯燥乏味又容易出错，因此我们需要一种通用的机制。最简单的，当然是把上面的代码封装成一个类：” 

class Counter 
{ 
public: 
    Counter(){ m_count++; }; 
    ~Counter(){ m_count--; }; 

    int GetCout(){ return m_count; }; 

private: 
    static int m_count; 
}; 

int Counter::m_count = 0; 

“然后在那些需要计数的类中添加一个 Counter 的成员，象这样：” 

class Wedget 
{ 
    …… 
    Counter m_MyCounter; 
}; 

“这样一来，新增一个 Wedget 对象也就新增一个 Counter 对象，销毁一个 Wedget 对象也就销毁一个 Counter 对象，看上去很完美。但是 ……”，zero 拖了个长音，“这样的解法是错误的！”说完，zero 在白板上夸张的打了一个大叉。 

看到台下人们疑惑的表情，zero 对自己行为戏剧性的效果感到非常满意，他得意洋洋的解释： 

“因为 static 成员是被该类所有的对象共享的，所以如果有另一个类，比如 Other 类也为了进行计数而包含了一个 m_MyCounter 成员的话，那么 Wedget 和 Other 类实际上是在共享一个计数值！请注意，Wedget 的 m_MyCounter 成员和 Other 的 m_MyCounter 成员都是 Counter 类的对象，它们共享同一个 m_count 静态变量。” 

“OK，要绕开这个问题，必须用一点点小手段，那就是模板：”，zero 在白板上写出如下的代码： 

template <class T> 
class Counter 
{ 
public: 
    Counter(){ m_count++; }; 
    ~Counter(){ m_count--; }; 

    int GetCout(){ return m_count; }; 

private: 
    static int m_count; 
}; 

template <class T> 
int Counter<T>::m_count = 0; 

class Wedget 
{ 
    …… 
    Counter<Wedget> m_MyCounter; 
}; 

class Other 
{ 
    …… 
    Counter<Other> m_MyCounter; 
}; 

“看出其中的区别了吗？Counter<Wedget> 和 Counter<Other> 是两个类，因此它们的 m_count 各自独立，就这样，我们实现了不同的类各自独立计数。” 

zero 一转身，惊讶的看到 Solmyr 不知什么时候已经出现在他座位上了，嘴边带着 —— 什么？没看错吧？zero 发现那不是 Solmyr 招牌式的坏笑，而是一种支持、赞许的微笑，zero 简直不能相信自己的眼睛。不过一转眼，Solmyr 的表情再度切换回了 zero 熟悉的模式 —— 快的让人以为刚才所看到的根本是幻觉 —— zero 心中一沉，知道事情有些不妙了，果然 —— 

“我来提个问题。”，Solmyr 发话了，而且笑的很灿烂 ……

“空泛的讨论让人厌烦。”，Solmyr 笑容可掬的说道，“不如我们设定一个简单的场景来看看你的计数器怎么使用吧。假设你是暴雪的程序员，要为星际争霸设计程序表示神族的单位，那么最简单的方案是 ——”，Solmyr 停了下来，望向 zero 。 

zero 松了一口气 —— 这个问题还不算困难。他在脑中整理了一下思路：“神族的单位应该设计为一个基类，然后每种特定的兵种从这个类派生，每个单位就是这样一个类的对象。”想到这里，他飞快的在百板上写下： 

class ProtossUnit 
{ 
    …… 
}; 

class Probe : public ProtossUnit 
{ 
    …… 
}; 

class Zealot : public ProtossUnit 
{ 
    …… 
}; 

class Dragoon : public ProtossUnit 
{ 
    …… 
}; 

Solmyr 点了点头，接着说到：“很好。接下来，我们都知道星际争霸里每个单位都是要占用人口的，也就是说我们得确切知道单位个数，很明显，这是一个对象计数的应用。那么我们该怎样利用你刚才实现的计数器呢？” 

zero 顺手就在白板上写下： 

class Probe : public ProtossUnit 
{ 
    …… 
    Counter<Probe> m_MyCounter; 
}; 

class Zeolot : public ProtossUnit 
{ 
    …… 
    Counter<Zeolot> m_MyCounter; 
}; 

class Dragoon : public ProtossUnit 
{ 
    …… 
    Counter<Dragoon> m_MyCounter; 
}; 

不对！！ 

zero 心中划过警兆：这感觉太熟悉了！几乎每次惨遭 Solmyr 毒手之前，都有这种感觉！他几乎都可以感受到 Solmyr 正在寻找顺手的东西来砸他。一定有什么地方不对了！ 

回过头来看看自己写下的东西，zero 很快的发现了自己的错误：Counter<Zeolot> 和 Counter<Dragoon> 是不同的类，它们的计数值各自独立，而星际争霸中各兵种占用人口是共享的。 

“既然是共享的，那么应该加到基类里。”，zero 急急忙忙的擦去了上面两行代码，写下： 

class ProtossUnit 
{ 
    …… 
    Counter<ProtossUnit> m_MyCounter; 
}; 

还 …… 还是不对！zero 立刻又发现了问题：不同的兵种可能占用的人口数并不相同，象 Probe 就只占用一个人口，而 Zealot 和 Dragoon 就要占用两个，这 …… 这 …… 

zero 再度擦去了刚写下的代码，站在白板之前举棋不定。这时 Solmyr 的声音响了起来：“怎么了？有困难吗？”。此时 Solmyr 脸上的笑容显得特别可恶。 

“不，我只是不清楚星际争霸中的人口是怎样定义的，这个游戏我从来没有玩过。”，zero 试图拖延一点时间。 

“是吗？昨天我怎么还听到你在讨论‘星际争霸神族战术’？而且刚才你一下子就写出了三个神族兵种的名称，拼写准确。”，Solmyr 轻易的戳破了 zero 的谎言。 

“……”，zero 不由得懊恼起来。“怎么办？得让它们共享一个计数器，而且每种兵种的计数值必须不一样 …… 对了！”zero 脑中灵光一闪，写下如下代码： 

class Probe : public ProtossUnit 
{ 
    …… 
    Counter<ProtossUnit> m_MyCounter; 
}; 

class Zeolot : public ProtossUnit 
{ 
    …… 
    Counter<ProtossUnit> m_MyCounter; 
    Counter<ProtossUnit> m_MyCounter; 
}; 

class Dragoon : public ProtossUnit 
{ 
    …… 
    Counter<ProtossUnit> m_MyCounter; 
    Counter<ProtossUnit> m_MyCounter; 
}; 

“Yeah！OK 了！”，zero 高兴的喊道，全然不顾台下带着笑意的目光 —— 这样的有趣场面已经成了公司里的著名娱乐之一。“共享一个计数器的关键是用哪个类别作为模板参数！不一定非得把本身作为模板参数，完全可以用各个兵种共同的基类！” 

“那计数值不是 1 呢？” 

“多放几个计数器就行了！” 

“嗯，还算不错。” 

zero 很高兴的看到 Solmyr 上前来在白板上打了一个勾，然而喜悦仅仅维持了一瞬间 —— Solmyr 顺手又在勾上打了一个点。 

“为什么打个点？”，zero 不满的问。 

“因为你的计数器设计不佳，想象一下 Carrier ，它占 8 个人口，你是不是要在 Carrier 类中写 8 个 Counter 成员？或者声明一个 Counter 的数组？这样的声明清晰吗？易读吗？” 

“呃 ……” 

“而且这样使用 Counter 成员变量，需要计数的对象在空间上会付出更大的代价，对于小对象，大小甚至可能翻一倍。” 

“嗯 ……” 

“更进一步的说，计数值为 n 的对象，需要构造 n 个 Counter 对象，运行性能也要受影响。” 

“啊 …… ” 

“现在你说说看，怎么改进你的计数器，同时不用改动原来的客户代码？” 

“哦 …… ” 

zero 陷入了沉思：改进后的计数器应该有指定计数值的能力，这个能力应该是 …… 应该是对应于一个计数器对象而非整个计数器类的，因为共享同一个计数器的类可能计数值不同，也就是说这里需要为计数器类的对象指定一个参数 …… 啊！原来这么简单！ 

“我知道了！答案就是构造函数！”，zero 飞快的把计数器类的定义改为（原来定义请参见上一期）： 

template <class T> 
class Counter 
{ 
public: 
    Counter(int step) // 改动部分 
    { 
        m_step = step; 
        m_count += m_step; 
    }; 
    ~Counter(){ m_count -= m_step; }; // 改动部分 

    int GetCout(){ return m_count; }; 

private: 
    static int m_count; 
    int m_step; // 新加部分 
}; 

“嗯，不错，不过还有问题。”，Solmyr 一边点头一边说，“这样一来，以前编写的使用 Counter 类的客户代码就不能编译了 —— 它们会报告说构造的时候少了一个参数。” 

“这好办。”，zero 很快发现了自己漏掉了什么。他把构造函数的定义改为： 

Counter(int step = 1) 

“这样一来，以前的客户代码会缺省的得到计数值 1 ，就像以前一样。” 

“嗯，表现不错，不过 ……” 

zero 心中一紧。 

“算了，今天就这样吧。” 

“Yeah！” 

“把今天这些讨论整理成详细文档，下班以前交给我” 

“啊！～～～～” 

……………… 

就这样，再一次的，故事在 zero 的惨叫声中结束了。