虚函数的默认参数问题。

disheng727

如下代码段：

1. 
   
2. class super {
   
3. public:
   
4.         virtual void somemethod()const { cout<<"base"<<endl; }
   
5. };
   
6. 
   
7. class sub : public super {
   
8. public:
   
9.         virtual void somemethod(int i = 12)const { cout<<"derive"<<endl; }
   
10. };
    
11. 
    
12. 
    
13. void test(void)
    
14. {
    
15.         sub mysub;
    
16.         mysub.somemethod();
    
17. 
    
18.         super &ref = mysub;
    
19.         ref.somemethod();    // 调用哪个？
    
20. }
    

复制代码

《C++高级编程》说 ref.somemethod() 调用会输出"derive" ，因为派生类的somemethod方法实际上覆盖了基类的somemethod方法。
但我在vs2008上测试结果为调用输出“base" 。觉得应该是书上说的有问题。如图：

zhujiang73

原帖由 disheng727 于 2010-1-3 22:11 发表
如下代码段：

class super {
public:
        virtual void somemethod()const { cout

带默认参数的不能多态。

应该是只能在基类中加默认参数才能正常工作。

[ 本帖最后由 zhujiang73 于 2010-1-3 23:17 编辑 ]

phy0077

virtural

int i=12

phy0077

virtual void somemethod()const { cout<<"base"<<endl; }
virtual void somemethod(int i = 12)const { cout<<"derive"<<endl; }


再查一下你源代码，
用debug模式

紫色的撒加

不知楼上说什么。。。
函数声明不一样不能多态

w_anthony

父类跟子类的参数要求不同，在虚表里面是占用不同的两个位置的，这样还是会调用父类的。
书上的父子类也是你这样定义的么？

churchmice

default argument 是early binding的，所以是i =12
virtual 还是存在的

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. class super {
   
5.     public:
   
6.         virtual void somemethod(int i=11)const { cout<<"base:"<<i<<endl; }
   
7. };
   
8. 
   
9. class sub : public super {
   
10.     public:
    
11.         virtual void somemethod(int i = 12)const { cout<<"derive:"<<i<<endl; }
    
12. };
    
13. 
    
14. 
    
15. int main(void)
    
16. {
    
17.           sub mysub;
    
18.           super &ref = mysub;
    
19.           ref.somemethod();
    
20.           return 0;
    
21. }
    

复制代码

[ 本帖最后由 churchmice 于 2010-1-5 12:21 编辑 ]

fxpbupt

摘自http://topic.csdn.net/u/20080410 ... 9-ba4fbba7e9ab.html



Effective C++ (这个貌似是第三版前的,不知道哪个版本,从电子书上搞下来的,3rd是条款37)

条款38: 决不要重新定义继承而来的缺省参数值

让我们从一开始就把问题简化。缺省参数只能作为函数的一部分而存在；另外，只有两种函数可以继承：虚函数和非虚函数。因此，重定义缺省参数值的唯一方法是重定义一个继承而来的函数。然而，重定义继承而来的非虚函数是一种错误（参见条款37），所以，我们完全可以把讨论的范围缩小为 "继承一个有缺省参数值的虚函数" 的情况。

既然如此，本条款的理由就变得非常明显：虚函数是动态绑定而缺省参数值是静态绑定的。

什么意思？你可能会说你不懂这些最新的面向对象术语；或者，过度劳累的你一时想不起静态和动态绑定的区别。那么，让我们来复习一下。

对象的静态类型是指你声明的存在于程序代码文本中的类型。看下面这个类层次结构：

enum ShapeColor { RED, GREEN, BLUE };

// 一个表示几何形状的类
class Shape {
public:
  // 所有的形状都要提供一个函数绘制它们本身
  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
                    /\
                  /  \
                  /    \
  Rectangle    Circle

现在看看这些指针：

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

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

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

这个例子中， ps， pc，和pr都被声明为Shape指针类型，所以它们都以此作为自己的静态类型。注意，这和它们真的所指向的对象的类型绝对没有关系 ---- 它们的静态类型总是Shape*。

对象的动态类型是由它当前所指的对象的类型决定的。即，对象的动态类型表示它将执行何种行为。上面的例子中，pc的动态类型是Circle*，pr的动态类型是Rectangle*。至于ps，实际上没有动态类型，因为它（还）没有指向任何对象。

动态类型，顾名思义，可以在程序运行时改变，典型的方法是通过赋值：

ps = pc;                        // ps的动态类型
                                // 现在是Circle*

ps = pr;                        // ps的动态类型
                                // 现在是Rectangle*

虚函数是动态绑定的，意思是说，虚函数通过哪个对象被调用，具体被调用的函数就由那个对象的动态类型决定：

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

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

我知道这些都是老掉牙的知识了，你当然也了解虚函数。（如果想知道它们是怎么实现的，参见条款M24）但是，将虚函数和缺省参数值结合起来分析就会产生问题，因为，如上所述，虚函数是动态绑定的，但缺省参数是静态绑定的。这意味着你最终可能调用的是一个定义在派生类，但使用了基类中的缺省参数值的虚函数：

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

这种情况下，pr的动态类型是Rectangle*，所以Rectangle的虚函数被调用 ---- 正如我们所期望的那样。Rectangle::draw中，缺省参数值是GREEN。但是，由于pr的静态类型是Shape*，这个函数调用的参数值是从Shape类中取得的，而不是Rectangle类！所以结果将十分奇怪并且出人意料，因为这个调用包含了Shape和Rectangle类中Draw的声明的组合。你当然不希望自己的软件以这种方式运行啦；至少，用户不希望这样，相信我。

不用说，ps， pc，和pr都是指针的事实和产生问题的原因无关。如果它们是引用，问题也会继续存在。问题仅仅出在，draw是一个虚函数，并且它的一个缺省参数在子类中被重新定义了。

为什么C++坚持这种有违常规的做法呢？答案和运行效率有关。如果缺省参数值被动态绑定，编译器就必须想办法为虚函数在运行时确定合适的缺省值，这将比现在采用的在编译阶段确定缺省值的机制更慢更复杂。做出这种选择是想求得速度上的提高和实现上的简便，所以大家现在才能感受得到程序运行的高效；当然，如果忽视了本条款的建议，就会带来混乱。

zhujiang73

原帖由 zhujiang73 于 2010-1-3 22:53 发表



带默认参数的不能多态。

应该是只能在基类中加默认参数才能正常工作。

发现两个 somemethod 类型不一样，一个有参数一个没参数。这不是多态，是笔误。

克拉玛依

书看少了。