Chinaunix首页 | 论坛 | 博客
  • 博客访问: 47478
  • 博文数量: 11
  • 博客积分: 140
  • 博客等级: 入伍新兵
  • 技术积分: 208
  • 用 户 组: 普通用户
  • 注册时间: 2012-06-22 00:51
个人简介

天外有天,人外有人。

文章分类

全部博文(11)

文章存档

2013年(10)

2012年(1)

我的朋友

分类: C/C++

2013-09-29 22:51:14

c++中多态分为静态多态和动态多态,在了解他们前,先了解3个相关的概念。
  • 函数重载(Overload):指在相同作用域里(如同一类中),函数同名不同参,反回值则不用理会,不同参可以是不同个数,也可以是不同类型。

效果:根据实参的个数和类型调用对应的函数体

  • 函数覆盖(override):指派生类中的函数覆盖基类中的同名同参虚函数,因此作用域不同。

效果:基类指针或引用访问虚函数时会根据实例的类型调用对应的函数。

点击(此处)折叠或打开

  1. Override实例:

  2. #include <iostream>
  3. #include <string>
  4. using namespace std;
  5. class base
  6. {
  7. public:
  8.         virtual void myname() //1.必须为虚函数
  9.         {
  10.                 cout<<"myname is base"<<endl;
  11.         }
  12. };
  13. class derived:public base
  14. {
  15. public:
  16.         void myname() //2.子类必须同名同参
  17.         {
  18.                 cout<<"myname is derived"<<endl;
  19.         }
  20. };
  21. int main()
  22. {
  23.         base* bPtr=new derived;
  24.        base* bPtr1=new base;
  25.         bPtr->myname(); //bPtr实际指向子类对象,override调用子类函数
  26.         bPtr1->myname(); // bPtr实际指向基类对象,override调用基类函数
  27.         delete bPtr;
  28.        delete bPtr1;
  29.         return 0;
  30. }
  31. 输出:
  32. myname is derived
  33. myname is base
 

函数隐藏(hide): 对于子类中与基数同名的函数,如果不是覆盖(override)那就成了隐藏(hide)2种情况:
   
1.       同名不同参。
       2.       同名同参但基类不是virtual函数。
效果:从对象类逐层上找,调用找到的第一个匹配函数,即基类函数被hide

Hideoverride的区别:Override采用虚表实现,隐藏采用一般函数实现。

静态多态与动态多态

1.     静态多态

静态多态是调用哪个函数是在编译时就确定的。常用函数重载和模板偏特化来实现。

对于传入不同类型参数却使用同一模板的情况,由于使用的是同一个代码段,因此不是多态。但模板和模板偏物化来说,由于不是同样的代码段,因此是多态。

实例:

点击(此处)折叠或打开

  1. #include <iostream>

  2. using namespace std;
  3. template<class T>
  4. T add(T a, T b)
  5. {
  6.         cout<<"template is called"<<endl;
  7.         return a+b;
  8. }
  9. template<>
  10. float add(float a, float b)
  11. {
  12.         cout<<"template specialize is invoked for float"<<endl;
  13.         return a+b;
  14. }
  15. int add(int a, int b)
  16. {
  17.         return a+b;
  18. }
  19. double add(double a, double b)
  20. {
  21.         return a+b;
  22. }
  23. int add(int a, int b, int c)
  24. {
  25.         return a+b+c;
  26. }
  27. double add(double a, double b, double c)
  28. {
  29.         return a+b+c;
  30. }
  31. int main()
  32. {
  33.         int i1=11, i2=22, i3=33;
  34.         double d1=1.1, d2=2.2, d3=3.3;
  35.     cout<<hex<<static_cast<int>(add(static_cast<char>(i1),
  36.                           static_cast<char>(i2)))<<endl;
  37.         cout<<"-------------------------------------------"<<endl;
  38.         cout<<dec;
  39.         cout<<add(static_cast<float>(d1), static_cast<float>(d2))<<endl;
  40.         cout<<"^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"<<endl;
  41.         cout<<"i1+i2="<<add(i1, i2)<<endl;
  42.         cout<<"i1+i2+i3="<<add(i1,i2,i3)<<endl;
  43.         cout<<"++++++++++++++++++++++++++++++++++++++++++++"<<endl;
  44.         cout<<"d1+d2="<<add(d1,d2)<<endl;
  45.         cout<<"d1+d2+d3="<<add(d1,d2,d3)<<endl;
  46.         cout<<"i1+d1="<<add(static_cast<double>(i1),d1)<<endl;
  47.         return 0;
  48. }

输出:

template is called

21

-------------------------------------------

template specialize is invoked for float

3.3

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

i1+i2=33

i1+i2+i3=66

++++++++++++++++++++++++++++++++++++++++++++

d1+d2=3.3

d1+d2+d3=6.6

i1+d1=12.1


运行时多态:

采用覆盖(override)实现,并且使用指针或引用来实现运行时多态,即使用虚函数表实现(参考另一篇虚函数表解析)。



 
阅读(1186) | 评论(0) | 转发(0) |
0

上一篇:虚函数表实例解析

下一篇:OOD 6大法则

给主人留下些什么吧!~~