读书笔记《Effective C++》条款37：绝不重新定义继承而来的缺省参数值

virtual函数系动态绑定，而缺省参数值却是静态绑定。静态绑定又名前期绑定，动态绑定又名后期绑定。

对象的所谓静态类型（static type），就是它在程序中被声明时所采用的类型。看以下例子：

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 {
		std::cout << "Rectangle draw" << std::endl;
	}
};

class Circle : public Shape {
public:
	//注意，当客户以Circle对象调用此函数，一定要指定参数值。
	//因为静态绑定下这个函数并不从其base继承缺省参数值。
	//但若以Shape指针（或reference)调用此函数，可以不指定参数值，
	//因为动态绑定下这个函数会从其base继承缺省参数值。
	virtual void draw(ShapeColor color) const {
		std::cout << "Circle draw" << std::endl;
	}
};

现在考虑这些指针：

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函数是动态绑定，而缺省参数值却是静态绑定。意思你可能会在“调用一个定义于derived class内的virtual函数”的同时，却使用base class为它所指定的缺省参数值：

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

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

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

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

这一切都很好，但如果试着遵守这条规则，并且同时提供缺省参数值给base和derived 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 = Red) const {
		std::cout << "Rectangle draw" << std::endl;
		std::cout << color << std::endl;
	}
};

这样draw函数的缺省参数虽然一致了，但是导致代码重复，更糟糕的是，代码重复又带着相依性：如果Shape内的缺省参数值改变了，所有“重复给定缺省参数值”的那些derived class也必须改变，否则它们最终会导致“重复定义一个继承而来的缺省参数值”。

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

class Shape {
public:
	enum ShapeColor {Red, Green, Blue};
	void draw(ShapeColor color = Red) const//如今是non-virtual
	{
		doDraw(color);//调用一个private virtual函数
	}
private:
	virtual void doDraw(ShapeColor color) const = 0;//真正的工作在此处完成
};

class Rectangle : public Shape {
private:
	virtual void doDraw(ShapeColor color) const;//注意，不须指定缺省参数值
};

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

要点：

绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而virtual函数——你唯一应该覆写的东西——却是动态绑定。