Item 37: 绝不要重定义一个函数的 inherited default parameter value(通过继承得到的缺省参数值)

作者:Scott Meyers

译者:fatalerror99 (iTePub's Nirvana)

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

我们直接着手简化这个话题。只有两种函数能被你 inherit(继承):virtual(虚拟的)和 non-virtual(非虚拟的)。然而,重定义一个 inherited non-virtual function(通过继承得到的非虚拟函数)永远都是一个错误(参见 Item 36),所以我们可以安全地将我们的讨论限制在你继承了一个 virtual function with a default parameter value(带有一个缺省参数值的虚拟函数)的情形。

在这种情况下,本 Item 的理由就变得非常地直截了当:virtual functions(虚拟函数)是 dynamically bound(动态绑定),而 default parameter values(缺省参数值)是 statically bound(静态绑定)。

那又怎样呢?你说 static(静态)和 dynamic binding(动态绑定)之间的区别早已塞入你负担过重的头脑?(不要忘了,static binding(静态绑定)也以 early binding(前期绑定)闻名,而 dynamic binding(动态绑定)也以 late binding(后期绑定)闻名。)那么,我们就再来回顾一下。

一个 object(对象)的 static type(静态类型)就是你在程序文本中声明给它的 type(类型)。考虑这个 class hierarchy(类继承体系):

// a class for geometric shapes
class Shape {
public:
  enum ShapeColor { Red, Green, Blue };

  // all shapes must offer a function to draw themselves
  virtual void draw(ShapeColor color = Red) const = 0;
  ...
};

class Rectangle: public Shape {
public:
  // notice the different default parameter value — bad!
  virtual void draw(ShapeColor color = Green) const;
  ...
};

class Circle: public Shape {
public:
  virtual void draw(ShapeColor color) const;
  ...
};

直观地看,它看起来就像这个样子:

现在考虑这些 pointers(指针):

Shape *ps;                       // static type = Shape*
Shape *pc = new Circle;          // static type = Shape*
Shape *pr = new Rectangle;       // static type = Shape*

在本例中,ps,pc 和 pr 全被声明为 pointer-to-Shape 类型,所以它们全都以此作为它们的 static type(静态类型)。注意这就使得它们真正指向的东西完全没有区别——无论如何,它们的 static type(静态类型)都是 Shape*。

一个 object(对象)的 dynamic type(动态类型)取决于它当前引用的 object(对象)的 type(类型)。也就是说,它的 dynamic type(动态类型)表明它有怎样的行为。在上面的例子中,pc 的 dynamic type(动态类型)是 Circle*,而 pr 的 dynamic type(动态类型)是 Rectangle*。至于 ps,它没有一个实际的 dynamic type(动态类型),因为它(还)不能引用任何 object(对象)。

dynamic types(动态类型),就像它的名字所暗示的,能在程序运行中变化,特别是通过 assignments(赋值):

ps = pc;                       // ps's dynamic type is
                               // now Circle*

ps = pr;                       // ps's dynamic type is
                               // now Rectangle*

virtual functions(虚拟函数)是 dynamically bound(动态绑定),意味着被调用的特定函数取决于被用来调用它的那个 object(对象)的 dynamic type(动态类型):

pc->draw(Shape::Red);             // calls Circle::draw(Shape::Red)

pr->draw(Shape::Red);             // calls Rectangle::draw(Shape::Red)

我知道,这全是老生常谈;你的确已经理解了 virtual functions(虚拟函数)。但是,当你考虑 virtual functions with default parameter values(带有缺省参数值的虚拟函数)时,就全乱了套,因为,如上所述,virtual functions(虚拟函数)是 dynamically bound(动态绑定),但 default parameters(缺省参数)是 statically bound(静态绑定)。这就意味着你最终调用了一个定义在 derived class(派生类)中的 virtual function(虚拟函数)却使用了一个来自 base class(基类)的 default parameter value(缺省参数值)。

pr->draw(); // calls Rectangle::draw(Shape::Red)!

在此情况下,pr 的 dynamic type(动态类型)是 Rectangle*,所以正像你所希望的,Rectangle 的 virtual function(虚拟函数)被调用。在 Rectangle::draw 中,default parameter value(缺省参数值)是 Green。然而,因为 pr 的 static type(静态类型)是 Shape*,这个函数调用的 default parameter value(缺省参数值)是从 Shape class 中取得的,而不是 Rectangle class!导致的结果就是一个调用由“奇怪的和几乎完全出乎意料的 Shape 和 Rectangle 两个 classes(类)中的 draw 声明的混合物”所组成。

ps,pc,和 pr 是 pointers(指针)的事实与这个问题并无因果关系,如果它们是 references(引用),问题依然会存在。唯一重要的事情是 draw 是一个 virtual function(虚拟函数),而它的一个 default parameter values(缺省参数值)在一个 derived class(派生类)中被重定义。

为什么 C++ 要坚持按照这种不正常的方式动作?答案是为了运行时效率。如果 default parameter values(缺省参数值)是 dynamically bound(动态绑定),compilers(编译器)就必须提供一种方法在运行时确定 virtual functions(虚拟函数)的 parameters(参数)的 default value(s)(缺省值),这比目前在编译期确定它们的机制更慢而且更复杂。最终的决定偏向了速度和实现的简单这一边,而造成的结果就是你现在可以享受高效运行的乐趣,但是,如果你忘记留心本 Item 的建议,就会陷入困惑。

这样就很彻底而且完美了,但是看看如果你试图遵循本规则为 base(基类)和 derived classes(派生类)的用户提供同样的 default parameter values(缺省参数值)时会发生什么:

class Shape {
public:
  enum ShapeColor { Red, Green, Blue };

  virtual void draw(ShapeColor color = Red) const = 0;
  ...
};

class Rectangle: public Shape {
public:
  virtual void draw(ShapeColor color = Red) const;
  ...
};

噢,code duplication(代码重复)。code duplication(代码重复)带来 dependencies(依赖关系):如果 Shape 中的 default parameter values(缺省参数值)发生变化,所有重复了它的 derived classes(派生类)必须同时变化。否则它们就陷入重定义一个 inherited default parameter value(通过继承得到的缺省参数值)。怎么办呢?

当你要一个 virtual function(虚拟函数)按照你希望的方式运行有困难的时候,考虑可选的替代设计是很明智的,而且 Item 35 给出了多个 virtual function(虚拟函数)的替代方法。替代方法之一是 non-virtual interface idiom (NVI idiom)(非虚拟接口惯用法):用 base class(基类)中的 public non-virtual function(公有非虚拟函数)调用 derived classes(派生类)可能重定义的 private virtual function(私有虚拟函数)。这里,我们用 non-virtual function(非虚拟函数)指定 default parameter(缺省参数),同时使用 virtual function(虚拟函数)做实际的工作:

class Shape {
public:
  enum ShapeColor { Red, Green, Blue };

  void draw(ShapeColor color = Red) const           // now non-virtual
  {
    doDraw(color);                                  // calls a virtual
  }

  ...

private:
  virtual void doDraw(ShapeColor color) const = 0;  // the actual work is
};                                                  // done in this func

class Rectangle: public Shape {
public:

  ...

private:
  virtual void doDraw(ShapeColor color) const;       // note lack of a
  ...                                                // default param val.
};

因为 non-virtual functions(非虚拟函数)绝不应该被 derived classes(派生类) overridden(覆盖)(参见 Item 36),这个设计使得 draw 的 color parameter(参数)的 default value(缺省值)应该永远是 Red 变得明确。

Things to Remember

绝不要重定义一个 inherited default parameter value(通过继承得到的缺省参数值),因为 default parameter value(缺省参数值)是 statically bound(静态绑定),而 virtual functions ——应该是你可以 overriding(覆盖)的仅有的函数——是 dynamically bound(动态绑定)。

powered by Gitbook 该教程制作时间: 2015-12-29 12:27:13