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

先将讨论简化。你只能继承两种函数：virtual和non-virtual函数。

然而重新定义一个继承而来的non-virtual函数永远是错的，所以将讨论的范围局限于“继承一个带有缺省参数值的virtual函数”。

如此，本条款成立的理由就很明确了：virtual函数是动态绑定，而缺省参数值是静态绑定。

静态绑定又名前期绑定；动态绑定又为后期绑定。 

一、静态绑定

对象的所谓静态类型，就是它在程序中被声明时所采用的类型。

考虑以下的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函数是动态绑定，而缺省参数值却是静态绑定。意思是你可能会在“调用一个定义于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;
    //...
};

上述代码造成了代码重复。更糟的是，代码重复又带着相依性。

若Shape内的缺省参数值改变了，所有”重复给定缺省参数值“的那些derived class也必须改变，否则，它们最终会导致”重复定义一个继承而来的缺省参数值”。

怎么办？

当你想令virtual函数表现出你所想要的行为但却遭遇麻烦，聪明的做法是考虑替代设计。

35这篇文章列了不少virtual函数的替代设计，其中之一是NVI手法。

这里可以让non-virtual函数指定缺省参数，而private class含糊负责真正的工作：

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 = Red) const;
    //...
};

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

总结

绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而virtual函数却是动态绑定。