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

–effective c++ item 37

首先,简化一下问题.你只能继承两种函数:virtual 和 non-virtual 函数 .而重新定义一个继承而来的non-virtual函数永远是错误的.所以现在只用讨论继承一个带有缺省参数的virtual 函数.

这样遵守规范的理由就显而易见了:virtual 函数 是 动态绑定 ,而缺省参数却是 静态绑定 .

动态绑定&静态绑定

静态绑定

对象的所谓静态类型 (static type) ,就是它在程序中被声明是所采用的类型.

考虑以下的继承体系:

// 一个用以描述几何形状的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;
};

这个继承体系图示如下:

现在考虑这些指针:

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的动态类型现在是Cricle*
ps = pr;                   // ps的动态类型现在是Rectangle*

pc->draw(Shape::RED);      // 调用Circle::draw(Shape::RED)
pr->draw(Shape::RED);      // 调用Rectangle::draw(Shape::RED)

---

virtual 函数缺省值

我们已经了解virtual 函数了. 但是当我们开始考虑带有缺省参数值的virtual 函数, 花花来了…因为之前说过, Virtual 函数是动态绑定, 而缺省参数却是静态绑定.
意思就是, 可能会在”调用一个定义于子类内的virtual 函数”的同时, 却使用基类为它所指定的缺省参数值.

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

上面的例子中,pr的动态类型是Rectangle* , 如注释中的代码一样, 但是由于pr的静态类型是Shape* .这样,调用的缺省数值来自Shape class 而不是 Rectangle 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 中的缺省参数改变了, 所有”重复给定缺省参数值”的那些子类也必须改变 .

---

玩花花

令基类内的一个 public non-virtual 函数 调用 private virtual 函数, 后者可被子类重新定义. 我们可以让 non-virtual 函数 指定缺省参数, 而 private virtual 函数 负责真正的工作.

具体看起来是这样:

class Shape {
public:
    enum ShapeColor { RED, GREEN, BLUE };
    void draw(ShapeColor color = RED) const
    {
        doDraw(color);
    }

private:
    virtual void doDraw(ShapeColor color) const = 0;
};

class Rectangle: public Shape {
public:

private:
    virtual void doDraw(ShapeColor color) const;
};

由于non-virtual 函数 不应该被子类重写, 这个设计很清楚使得draw函数的color参数总是RED..