C++箴言：绝不重定义继承的非虚拟函数

　　假设我告诉你 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（通过继续得到的非虚拟函数）的理论上的理由。我很愿意效劳。

　　前文解释了 public inheritance（公有继续）意味着 is-a，在《C++箴言：接口继续和实现继续》一文中记述了为什么在一个 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（通过继续得到的非虚拟函数）。

　　假如阅读本文给你 déjà vu（似曾相识）的感觉，那可能是因为你已经阅读了《C++箴言：多态基类中将析构函数声明为虚拟》，该文解释了为什么 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（派生类）这也是成立的，因为，就像《C++箴言:了解C++偷偷加上和调用了什么》中的解释，destructor（析构函数）是一个“假如你没有定义你自己的，编译器就会为你生成一个”的 member functions（成员函数）。其实，《C++箴言：多态基类中将析构函数声明为虚拟》只相当于本文的一个非凡情况，尽管它重要到足以把它提出来独立成篇。

　　Things to Remember

　　·绝不要重定义一个 inherited non-virtual function（通过继续得到的非虚拟函数）。