C++基础--------带默认参数的虚函数 静态类型和动态类型分析

来源:互联网 发布:期刊代理中介知乎 编辑:程序博客网 时间:2024/06/01 08:27
  1. // 字串查找.cpp : 定义控制台应用程序的入口点。   
  2. //   
  3. #include "stdafx.h"   
  4. #include <iostream>   
  5. #include <complex>   
  6. using namespace std;  
  7. class base{  
  8. public:  
  9.     base(){  
  10.         cout<<"base::base()\n";  
  11.     }  
  12.     ~base(){  
  13. cout<<"base::~base()\n";  
  14.     }  
  15.     virtual void f(int){  
  16.         cout<<"base::f(int)\n";  
  17.     }  
  18.     virtual void f(double){  
  19.         cout<<"base::f(double)\n";  
  20.     }  
  21.     virtual void g(int i=10){  
  22.         cout<<"base::g()"<<i<<endl;  
  23.     }  
  24. };  
  25.   
  26. class derived:public base{  
  27. public:  
  28.     derived(){  
  29.         cout<<"derived::derived()\n";  
  30.     }  
  31.     ~derived(){  
  32.         cout<<"derived::~derived()\n";  
  33.     }  
  34.     void f(complex<double> c){  
  35.         cout<<"derived:f(complex)\n";  
  36.     }  
  37.     virtual void g(int i=20){  
  38.         cout<<"derived::g()"<<i<<endl;  
  39.     }  
  40. };  
  41. int _tmain(int argc, _TCHAR* argv[])  
  42. {  
  43.     base b;  
  44.     derived d;  
  45.     base *pb=new derived;  
  46.     cout<<sizeof(base)<<endl;  
  47.     cout<<sizeof(derived)<<endl;  
  48.     pb->f(1.0);  
  49.     pb->g();  
  50.     getchar();  
  51.     return 0;  
  52. }  

pb->g(); 在base和derived都定义了含有相同参数列表的g(),因此这里发生多态。pb指针指向的是derived类的对象,因此调用的是derived类的g().这里注意,由于参数值是在编译期就已经决定的,因此参数i应该取base类的默认值,即10

 

例2:

[cpp] view plaincopyprint?
  1. #include <iostream>   
  2. #include <complex>   
  3. using namespace std;  
  4. class A{  
  5. public:  
  6.     virtual void its(const charconst str="A"){  
  7.         cout << "This is A str=" << str << endl;  
  8.     }  
  9.     static void show(A & obj){  
  10.         obj.its();  
  11.     }  
  12. };  
  13.   
  14. class B : public A{  
  15. public:  
  16.     virtual void its(const charconst str="B"){  
  17.         cout << "This is B str=" << str << endl;  
  18.     }  
  19. };  
  20.   
  21. class C : public A{  
  22. public:  
  23.     virtual void its(const charconst str="C"){  
  24.         cout<<"This is C str="<<str<<endl;  
  25.     }  
  26. };  
  27.   
  28. int _tmain(int argc, _TCHAR* argv[])  
  29. {  
  30.     C cc;  
  31.     B bb;  
  32.     A::show(cc);  
  33.     A::show(bb);  
  34.     bb.its();  
  35.     cc.its();  
  36.     int i=2;  
  37.     const int &a=i;  
  38.     getchar();  
  39.     return 0;  
  40. }  


默认参数在编译的时候已经写死了,不会动态的。

例3:

[cpp] view plaincopyprint?
  1. #include "stdafx.h"   
  2. #include <iostream>   
  3. #include <complex>   
  4. using namespace std;  
  5. enum ShapeColor{RED,GREEN,BLUE};  
  6. //一个表示集合形状的类   
  7. class Shape{  
  8. public:  
  9.     //所有的形状都要提供一个函数憨直它们本身   
  10.     virtual void draw(ShapeColor color=RED) const =0;  
  11. };  
  12.   
  13. class Rectangle:public Shape{  
  14. public:  
  15.     //定义了不同的缺省参数值   
  16.     virtual void draw(ShapeColor color=GREEN) const{  
  17.         cout<<"Rectangle::draw "<<color<<endl;  
  18.     }  
  19. protected:  
  20. private:  
  21. };  
  22. class Circle:public Shape{  
  23. public:  
  24.     virtual void draw(ShapeColor color) const{  
  25.     cout<<"Circle::draw "<<color<<endl;  
  26.     }  
  27. protected:  
  28. private:  
  29. };  
  30. int _tmain(int argc, _TCHAR* argv[])  
  31. {  
  32.     //ps,pc,pr都被声明为Shape指针类型,所以他们都以此作为自己的静态类型。   
  33.     Shape *ps,*pc,*pr;  
  34.     pc=new Circle;  //静态类型=Shape*  
  35.     pc->draw(BLUE);  
  36.     pr=new Rectangle;//静态类型=Shape*  
  37.     pr->draw();  
  38.     getchar();  
  39.     return 0;  
  40. }  


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

原创粉丝点击