Item 36: 绝不要重定义一个 inherited non-virtual function(通过继承得到的非虚拟函数)

作者:Scott Meyers

译者:fatalerror99 (iTePub's Nirvana)

发布:http://blog.csdn.net/fatalerror99/

假设我告诉你 class(类)D 从 class(类)B publicly derived(公有继承),而且在 class(类)B 中定义了一个 public member function(公有成员函数)mf。mf 的参数和返回值类型是无关紧要的,所以我们就假设它们都是 void。换句话说,我的意思是:

class B {
public:
  void mf();
  ...
};
class D: public B { ... };

甚至不必知道关于 B,D,或 mf 的任何事情,给定一个类型为 D 的 object(对象)x,

D x; // x is an object of type D

对此你或许非常吃惊,

B *pB = &x; // get pointer to x

pB->mf(); // call mf through pointer

的行为不同于以下代码:

D *pD = &x; // get pointer to x

pD->mf(); // call mf through pointer

因为在两种情况中,你都调用了 object(对象)x 中的 member function(成员函数)mf。因为两种情况中都是同样的 function(函数)和同样的 object(对象),它们的行为应该有相同的方式,对吗?

是的,应该。但是也可能不,特别地,如果 mf 是 non-virtual(非虚拟)而 D 定义了它自己的版本的 mf:

class D: public B {
public:
  void mf();                      // hides B::mf; see Item33

  ...

};

pB->mf();                         // calls B::mf

pD->mf();                         // calls D::mf

这种行为两面性的原因是像 B::mf 和 D::mf 这样的 non-virtual functions(非虚拟函数)是 statically bound(静态绑定)的(参见 Item 37)。这就意味着因为 pB 被声明为 pointer-to-B 类型,所以,即使就像本例中的做法,让 pB 指向一个从 B 继承的类的对象,通过 pB 调用的 non-virtual functions(非虚拟函数)也总是定义在 class B 中的那一个。

在另一方面,virtual functions(虚拟函数)是 dynamically bound(动态绑定)的(再次参见 Item 37),所以它们不会发生这个问题。如果 mf 是一个 virtual function(虚拟函数),无论通过 pB 还是 pD 调用 mf 都将导致 D::mf 的调用,因为 pB 和 pD 都实际地指向一个 type(类型)D 的 object(对象)。

如果你在编写 class D 而且你重定义了一个你从 class B 继承到的 non-virtual function(非虚拟函数)mf,D 的 objects(对象)将很可能表现出不协调的行为。特别是,当 mf 被调用时,任何给定的 D object(对象)的行为既可能像 B 也可能像 D,而且决定因素与 object(对象)本身无关,但是和指向它的 pointer(指针)的声明类型有关。references(引用)也会像 pointers(指针)一样表现出莫名其妙的行为。

但这仅仅是一个从实用出发的论据。我知道,你真正需要的是不能重定义 inherited non-virtual functions(通过继承得到的非虚拟函数)的理论上的理由。我很愿意效劳。

Item 32 解释了 public inheritance(公有继承)意味着 is-a,Item 34 记述了为什么在一个 class(类)中声明一个 non-virtual function(非虚拟函数)是为这个 class(类)设定一个 invariant over specialization(超越特殊化的不变量),如果你将这些经验应用于 classes(类)B 和 D 以及 non-virtual member function(非虚拟函数)B::mf,那么:

每一件适用于 B objects(对象)的事情也适用于 D objects(对象),因为每一个 D objects 都 is-a(是一个)D objects(对象);

从 B 继承的 classes(类)必须同时继承 mf 的 interface(接口)和 implementation(实现),因为 mf 在 B 中是 non-virtual(非虚拟)的。

现在,如果 D 重定义 mf,你的设计中就有了一处矛盾。如果 D 真的需要实现不同于 B 的 mf,而且如果每一个 B objects(对象)——无论如何特殊——都必须使用 B 对 mf 的实现,那么每一个 D 都 is-a(是一个)B 就完全不成立。在那种情况下,D 就不应该从 B publicly inherit(公有继承)。另一方面,如果 D 真的必须从 B publicly inherit(公有继承),而且如果 D 真的需要实现不同于 B 的 mf,那么 mf 反映了一个 B 的 invariant over specialization(超越特殊化的不变量)就不会成立。在那种情况下,mf 应该是 virtual(虚拟)的。最后,如果每一个 D 真的都 is-a(是一个)B,而且如果 mf 真的相当于一个 B 的 invariant over specialization(超越特殊化的不变量),那么 D 就不会真的需要重定义 mf,而且想都不能想。

不管使用那一条规则,必须做出某些让步,而且无条件地禁止重定义一个 inherited non-virtual function(通过继承得到的非虚拟函数)。

如果阅读这个 Item 给你 déjà vu(似曾相识)的感觉,那可能是因为你已经阅读了 Item 7,那个 Item 解释了为什么 polymorphic base classes(多态基类)中的 destructors(析构函数)应该是 virtual(虚拟)的。如果你违反了那个 guideline(指导方针)(例如,如果你在一个 polymorphic base class(多态基类)中声明一个 non-virtual destructor(非虚拟析构函数)),你也同时违反了这里这个 guideline(指导方针),因为 derived classes(派生类)总是要重定义一个 inherited non-virtual function(通过继承得到的非虚拟函数):base class(基类)的 destructor(析构函数)。甚至对于没有声明 destructor(析构函数)的 derived classes(派生类)这也是成立的,因为,就像 Item 5 的解释,destructor(析构函数)是一个“如果你没有定义你自己的,编译器就会为你生成一个”的 member functions(成员函数)。其实,Item 7 只相当于本 Item 的一个特殊情况,尽管它重要到足以把它提出来独立成篇。

Things to Remember

绝不要重定义一个 inherited non-virtual function(通过继承得到的非虚拟函数)。