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（通过继承得到的非虚拟函数）。