绝不重新定义继承而来的缺省参数值—

本文链接：https://blog.csdn.net/yj_android_develop/article/details/107167204

让我们一开始就将讨论简单化。你只能继承两种函数：virtual和non-virtual函数。然而重新定义继承而来的non-virtual函数永远是错误的（见条款36），所以我们可以安全地将本条款的讨论局限于“继承一个带有缺省参数值的virtual函数”。

这种情况下，本条款成立的理由就非常直接而明确了：virtual函数系动态绑定（dynamically bound），而缺省参数值却是静态绑定（statically bound）。

对象的所谓静态类型（static type），就是它在程序中被声明时所采用的类型。考虑以下的class继承体系：

// 一个用以描述几何形状的class
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 = Green) const;
	...
};
class Circle: public Shape {
public:
	virtual void draw(ShapeColor color) const;
	// 译注：请注意，以上这么写则当客户以对象调用此函数，一定要指定参数值。
	// 因为静态绑定下这个函数并不从其base继承缺省参数值。
	// 但若以指针（或reference）调用此函数，可以不指定参数值，
	// 因为动态绑定下这个函数会从其base继承缺省参数值。
	...
};

这个继承体系图示如下：

现在考虑这些指针：

Shape* ps; // 静态类型为Shape*

Shape* pc = new Circle; // 静态类型为Shape*

Shape* pr = new Rectangle; // 静态类型为Shape*

本例中ps，pc和pr都被声明为pointer-to-Shape类型，所以它们都以它为静态类型。注意，不论它们真正指向什么，它们的静态类型都是Shape*。

对象的所谓动态类型（dynamic type）则是指“目前所指对象的类型”。也就是说，动态类型可以表现出一个对象将会有什么行为。以上例而言，pc的动态类型是Circle*，pr的动态类型是Rectangle*。ps没有动态类型，因为它尚未指向任何对象。

动态类型一如其名称所示，可在程序执行过程中改变（通常是经由赋值动作）：

ps = pc; // ps的动态类型如今是Circle*

ps = pr; // ps的动态类型如今是Rectangle*

Virtual函数系动态绑定而来，意思是调用一个virtual函数时，究竟调用哪一份函数实现代码，取决于发出调用的那个对象的动态类型：

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

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

我知道这些都是老调重弹；是的，你当然已经了解virtual函数。但是当你考虑带有缺省参数值的virtual函数，花样来了，因为就如我稍早所说，virtual函数是动态绑定，而缺省参数值却是静态绑定。意思是你可能会在“调用一个定义于derived class内的virtual函数”的同时，却使用base class为它所指定的缺省参数值：

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

此例之中，pr的动态类型是Rectangle*，所以调用的是Rectangle的virtual函数，一如你所预期。Rectangle::draw函数的缺省参数值应该是GREEN，但由于pr的静态类型是Shape*,所以此一调用的缺省参数值应该是GREEN，但由于pr的静态类型是Shape*,所以此一调用的缺省参数值来自Shape class而非Rectangle class！结局是这个函数调用有着奇怪并且几乎绝对没人预料得到的组合，由Shape class和Rectangle class的draw声明式各出一半力。

以上事实不只局限于“ps，pc和pr都是指针”的情况：即使把指针换成references问题仍然存在。重点在于draw是个virtual函数，而它有个缺省参数值在derived class中被重新定义了。

为什么C++坚持以这种乖张的方式来运作呢？答案在于运行期效率。如果缺省参数值是动态绑定，编译器就必须有某种办法在运行期为virtual函数决定适当的参数缺省值。这比目前实行的“在编译器决定”的机制更慢而且更复杂。为了程序的执行速度和编译器实现上的简易度，C++做了这样的取舍，其结果就是你如今所享受的执行效率。但如果你没有注意本条款所揭示的忠告，很容易发生混淆。

这一切都很好，但如果你试着遵守这条规则，并且同时提供缺省参数值给base和derived classes的用户，又会发生什么事呢？

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;
	...
};

喔噢，代码重复。更糟的是，代码重复又带着相依性（with dependencies）：如果Shape内的缺省参数值改变了，所有“重复给定缺省参数值”的那些derived classes也必须改变，否则它们最终会导致“重复定义一个继承而来的缺省参数值”。怎么办？

当你想令virtual函数表现出你所想要的行为但却遭遇麻烦，聪明的做法是考虑替代设计。条款35列了不是virtual函数的替代设计，其中之一是NVI（non-virtual interface）手法：令base class内的一个public non-virtual函数调用private virtual函数，后者可被derived classes重新定义。这里我们可以让non-virtual函数指定缺省参数，而private virtual函数负责真正的工作：

class Shape {
public:
	enum ShapeColor { Red, Green, Blue };
	void draw(ShapeColor color = Red) const      // 如今它是non-virtual
	{
		doDraw(color);                           // 调用一个virtual
	}
	...
private:
	virtual void doDraw(ShapeColor color) const = 0;  // 真正的工作在此处完成
};
class Rectangle: public Shape {
public:
	...
private:
	virtual void doDraw(ShapeColor color) const;     // 注意，不须指定缺省参数值
	...
};

由于non-virtual函数应该绝对不被derived classes覆写（见条款36），这个设计很清楚地使得draw函数的color缺省参数值总为Red。

请记住