绝不要重新定义继承而来的缺省参数值（Effective C++_37）

一、考虑以下代码
代码来源：http://blog.csdn.net/cadcisdhht/article/details/6233170

class A
{
public:
   virtual void Fun(int number = 10)
   {
       std::cout << "A::Fun with number " << number;
   }
};

class B:public A
{
public:
   virtual void Fun(int number = 20)
   {
       std::cout << "B::Fun with number " << number;
   }
};

int main()
{
   B b;
   A &a = b;
   a.Fun();
}

结果：

B::Fun with number 10请按任意键继续. . .

分析：由于a是一个指向B实例的引用，因此在运行的时候会调用B::Fun。但缺省参数是在编译期决定的。在编译的时候，编译器只知道a是一个类型a的引用，具体指向什么类型在编译期是不能确定的，因此会按照A::Fun的声明把缺省参数number设为10。
这一题的关键在于理解确定缺省参数的值是在编译的时候，但确定引用、指针的虚函数调用哪个类型的函数是在运行的时候。

---

二、不要重新定义继承而来的虚函数缺省参数值
注：引自http://www.cnblogs.com/lidan/archive/2012/02/11/2347062.html

重新定义一个继承而来的non-virtual函数永远都是错误的，本条款的讨论限制在“带有缺省参数的virtual函数”。

virtual函数是动态绑定的，而缺省参数却是静态绑定。

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

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不论这些指针指向什么，它们的静态类型都是Shape*

对象的所谓动态类型则是指“目前所指对象的类型”。可以在程序执行过程中改变

ps = pr;
ps = pc;

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

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

考虑带有缺省参数的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！

即使把指针换成reference，问题仍然存在。

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

如果你遵守这条规则，并且同时提供缺省参数值给base和derived classes的用户，又会发生什么呢?

class Shape { 
public: 
    enum {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 classes也必须改变，否则它们最终导致“重复定义一个继承而来的缺省参数值”。

怎么办？

当你想令virtual函数表现你所想要的行为却遭遇麻烦，聪明的做法是考虑替代设计。条款35。其中之一就是NVI手法：

令base class内的一个public non-virtual函数调用一个private virtual函数，后者可被derived classes重新定义（重新定义后一样的可以实现多态，因为non-virtual函数调用virtual函数）。这里我们可以让non-virtual函数指定缺省参数，而private virtual函数负责真正的工作：

class Shape { 
public: 
    enum {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函数应该绝对不被derived classes覆写（条款36），这个设计很清楚的使draw函数的color缺省参数值总为Red。

在重新考虑以下一中改动的代码

class A
{
public:
     void fun1(int number=10){
        Fun(number);
    }

private:
     virtual void Fun(int number)
   {
       std::cout << "A::Fun with number " << number;
   }
};

class B:public A
{

private:
   virtual void Fun(int number)
   {
       std::cout << "B::Fun with number " << number;
   }
};

int main()
{
    A* a;
    a=new B;
    a->fun1();
    return 0;

}

结果仍然相同，缺省参数总是10