中国领先的IT技术网站
|
|

C++ 成员函数的重载,继承,覆盖和隐藏

在调用pBase->f(5)时,首先要去pBase类中找到对应需要执行的函数,因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载,因为该实参是5,为int类型,所以要调用virtual void f(int a)函数,因为该f(int a)是一个虚函数,所以再去判断pBase所指向的具体对象,具体对象为Derived子类,再去Derived子类的虚函数表中找到void f(int a)函数

作者:2cto来源:2cto|2016-12-26 09:23

开发者大赛路演 | 12月16日,技术创新,北京不见不散


一、 C++成员函数的重载

C++中的成员函数有四种,分别是普通成员函数,virtual虚函数,const成员函数。

  • (1) void func(int a);

  • (2) virtual void func(int a);

  • (3) void func(int a) const;

如果在一个类中,声明这四种函数,哪是重复定义?哪些是重载?

其中(1)(2)是重复定义,故编译不能通过,而(3)与(1)(2)是不同类型的函数,是重载。

成员函数被重载的特征是:

  • (1)具有相同的作用域(即同一个类定义中);

  • (2)函数名字相同

  • (3)参数类型,顺序 或 数目不同(包括const参数和非const函数)

  • (4)virtual关键字可有可无。

从成员函数的重载特征中,可以知道(1)(2)是重复定义。那么(3)为什么和(1)(2)不同呢?

因为类中的函数,都会自动添加一个自身类指针this,所以

  1. void func(int a) ==== void func(Base * thisint a) 
  2. virtual func(int a) ==== virtual func(Base *thisint a) 
  3. void func(int a)const === void func(const Base *thisint a) const 

所以(3)可以与(1)(2)发生重载,因为参数有一个const。

二 、C++成员函数的继承

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class Base {  
  5. public:  
  6.     void f(int a){  
  7.         cout << "Base::f(int a)" << endl;  
  8.     }  
  9.     virtual void g(int a) {  
  10.         cout << "virtual Base::g(int a)" << endl;  
  11.     }  
  12. };  
  13.  
  14. class Derived : public Base  
  15. {  
  16. public:  
  17.     void h(int a) {  
  18.         cout << "Derivd::h(int a)" << endl;  
  19.     }  
  20. };  
  21.  
  22. int main()  
  23. {  
  24.     Base b;  
  25.     b.f(3);  
  26.     b.g(4);  
  27.  
  28.     Derived d;  
  29.     d.f(3);  
  30.     d.g(4);  
  31.     d.h(3);  
  32. }  
  33.  
  34. #include <iostream> 
  35. using namespace std; 
  36.  
  37. class Base { 
  38. public
  39.  void f(int a){ 
  40.   cout << "Base::f(int a)" << endl; 
  41.  } 
  42.  virtual void g(int a) { 
  43.   cout << "virtual Base::g(int a)" << endl; 
  44.  } 
  45. }; 
  46.  
  47. class Derived : public Base 
  48. public
  49.  void h(int a) { 
  50.   cout << "Derivd::h(int a)" << endl; 
  51.  } 
  52. }; 
  53.  
  54. int main() 
  55.  Base b; 
  56.  b.f(3); 
  57.  b.g(4); 
  58.  
  59.  Derived d; 
  60.  d.f(3); 
  61.  d.g(4); 
  62.  d.h(3); 

Base b的对象模型:

Derived d的对象模型:

则在子类Derived d中继承了父类中的virtual void g(int a) ; void f(int a);

运行结果为:

三、C++成员函数的覆盖

覆盖是指派生类重新实现(或者改写)了基类的成员函数,其特征是:

  • (1)不同的作用域(非别位于派生类和基类中);

  • (2)函数名称相同

  • (3)参数列表完全相同;

  • (4)基类函数必须是虚函数。

从(4)中我们得知覆盖只是针对虚函数的。

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class Base {  
  5. public:  
  6.     void f(int a){  
  7.         cout << "Base::f(int a)" << endl;  
  8.     }  
  9.     virtual void g(int a) {  
  10.         cout << "virtual Base::g(int a)" << endl;  
  11.     }  
  12. };  
  13.  
  14. class Derived : public Base  
  15. {  
  16. public:  
  17.     void h(int a) {  
  18.         cout << "Derivd::h(int a)" << endl;  
  19.     }  
  20.     virtual void g(int a) {  
  21.         cout << "virtual Derived::g(int a)" << endl;  
  22.     }  
  23. };  
  24.  
  25. int main()  
  26. {  
  27.     Base b;  
  28.     b.f(3);  
  29.     b.g(4);  
  30.  
  31.     Derived d;  
  32.     d.f(3);  
  33.     d.g(4);  
  34.     d.h(3);  
  35. }  
  36.  
  37. #include <iostream> 
  38. using namespace std; 
  39.  
  40. class Base { 
  41. public
  42.  void f(int a){ 
  43.   cout << "Base::f(int a)" << endl; 
  44.  } 
  45.  virtual void g(int a) { 
  46.   cout << "virtual Base::g(int a)" << endl; 
  47.  } 
  48. }; 
  49.  
  50. class Derived : public Base 
  51. public
  52.  void h(int a) { 
  53.   cout << "Derivd::h(int a)" << endl; 
  54.  } 
  55.  virtual void g(int a) { 
  56.   cout << "virtual Derived::g(int a)" << endl; 
  57.  } 
  58. }; 
  59.  
  60. int main() 
  61.  Base b; 
  62.  b.f(3); 
  63.  b.g(4); 
  64.  
  65.  Derived d; 
  66.  d.f(3); 
  67.  d.g(4); 
  68.  d.h(3); 

Derived d对象模型如下:

其中Derived中重新定义了基类的虚成员函数virtual void g(int a);

四、C++成员函数的隐藏

隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数,具体规则如下:

(1) 派生类的函数与基类的函数同名,但是参数列表有所差异。此时,不论有无virtual关键字,基类的函数在派生类中将被隐藏。(注意别与重载混合)

(2)派生类的函数与基类的函数同名,参数列表也相同,但是基类函数没有virtual关键字。此时,基类的函数在派生类中将被吟唱。(注意别与覆盖混合)

判断下面哪些函数是覆盖,哪些函数是隐藏?

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class Base {  
  5. public:  
  6.     virtual void f(float x) {  
  7.         cout << "virtual Base::f(float) " << x << endl;  
  8.     }  
  9.     void g(float x) {  
  10.         cout << "Base::g(float) " << x << endl;  
  11.     }  
  12.     void h(float x) {  
  13.         cout << "Base::h(float) " << x << endl;  
  14.     }  
  15. };  
  16.  
  17. class Derived : public Base{  
  18. public:  
  19.     virtual void f(float x) {  
  20.         cout << "virtual Derived::f(float) " << x << endl;  
  21.     }  
  22.     void g(int x) {  
  23.         cout << "Derived::g(int) " << x << endl;  
  24.     }  
  25.     void h(float x) {  
  26.         cout << "Derived::h(float) " << x << endl;  
  27.     }  
  28. };  
  29.  
  30. int main(void)  
  31. {  
  32.     Derived d;  
  33.     Base *pb = &d;  
  34.     Derived *pd = &d;  
  35.  
  36.     pb->f(3.14f);  
  37.     pd->f(3.14f);  
  38.  
  39.     pb->g(3.14f);  
  40.     pd->g(3.14f);  
  41.  
  42.     pb->h(3.14f);  
  43.     pd->h(3.14f);  
  44. }  
  45.  
  46. #include <iostream> 
  47. using namespace std; 
  48.  
  49. class Base { 
  50. public
  51.  virtual void f(float x) { 
  52.   cout << "virtual Base::f(float) " << x << endl; 
  53.  } 
  54.  void g(float x) { 
  55.   cout << "Base::g(float) " << x << endl; 
  56.  } 
  57.  void h(float x) { 
  58.   cout << "Base::h(float) " << x << endl; 
  59.  } 
  60. }; 
  61.  
  62. class Derived : public Base{ 
  63. public
  64.  virtual void f(float x) { 
  65.   cout << "virtual Derived::f(float) " << x << endl; 
  66.  } 
  67.  void g(int x) { 
  68.   cout << "Derived::g(int) " << x << endl; 
  69.  } 
  70.  void h(float x) { 
  71.   cout << "Derived::h(float) " << x << endl; 
  72.  } 
  73. }; 
  74.  
  75. int main(void
  76.  Derived d; 
  77.  Base *pb = &d; 
  78.  Derived *pd = &d; 
  79.  
  80.  pb->f(3.14f); 
  81.  pd->f(3.14f); 
  82.  
  83.  pb->g(3.14f); 
  84.  pd->g(3.14f); 
  85.  
  86.  pb->h(3.14f); 
  87.  pd->h(3.14f); 

其中子类Derived中 vitual void f(float x)  是覆盖,而void g(int x) 和void h(float x)都是隐藏。

运行结果:

再看一个例子:

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class Base  
  5. {  
  6. public:  
  7.     virtual void f(int a) {  
  8.         cout << "virtual Base::f(int a)" << endl;  
  9.     }  
  10.  
  11.     void f(double d) {  
  12.         cout << "Base::f(double d)" << endl;   
  13.     }  
  14. };  
  15.  
  16. class Derived : public Base  
  17. {  
  18. public:  
  19.  
  20.     void f(double d) {  
  21.         cout << "Derivd::f(double d)" << endl;  
  22.     }  
  23. };  
  24.  
  25. int main()  
  26. {  
  27.     Derived d;  
  28.     d.f(3);  
  29.     d.f(2.5);  
  30.  
  31.     Derived *pd = new Derived();  
  32.     pd->f(3);  
  33.     pd->f(2.5);  
  34.  
  35.     Base b;  
  36.     b.f(5);  
  37.     b.f(3.5);  
  38.  
  39.     Base *pBase = new Derived();  
  40.     pBase->f(5);  
  41.     pBase->f(3.5);  
  42. }  
  43.  
  44. #include <iostream> 
  45. using namespace std; 
  46.  
  47. class Base 
  48. public
  49.  virtual void f(int a) { 
  50.   cout << "virtual Base::f(int a)" << endl; 
  51.  } 
  52.  
  53.  void f(double d) { 
  54.   cout << "Base::f(double d)" << endl; 
  55.  } 
  56. }; 
  57.  
  58. class Derived : public Base 
  59. public
  60.  
  61.  void f(double d) { 
  62.   cout << "Derivd::f(double d)" << endl; 
  63.  } 
  64. }; 
  65.  
  66. int main() 
  67.  Derived d; 
  68.  d.f(3); 
  69.  d.f(2.5); 
  70.  
  71.  Derived *pd = new Derived(); 
  72.  pd->f(3); 
  73.  pd->f(2.5); 
  74.  
  75.  Base b; 
  76.  b.f(5); 
  77.  b.f(3.5); 
  78.  
  79.  Base *pBase = new Derived(); 
  80.  pBase->f(5); 
  81.  pBase->f(3.5); 

其中父类中的void f(double d)隐藏了子类的virtual void f(int a),  void f(double d)函数。

所以在主函数中

  1. Derived d;  
  2. d.f(3);  
  3. d.f(2.5);  
  4.  
  5. Derived *pd = new Derived();  
  6. pd->f(3);  
  7. pd->f(2.5);  
  8.  
  9. Derived d; 
  10. d.f(3); 
  11. d.f(2.5); 
  12.  
  13. Derived *pd = new Derived(); 
  14. pd->f(3); 
  15. pd->f(2.5);只要通过Derived对象或者Derived指针执行f()函数,都只执行void Derived::f(double d)该函数。 
  16.  
  17. [html] 
  18. Base *pBase = new Derived();  
  19. pBase->f(5);  
  20. pBase->f(3.5);  
  21.  
  22. Base *pBase = new Derived(); 
  23. pBase->f(5); 
  24. pBase->f(3.5); 

在调用pBase->f(5)时,首先要去pBase类中找到对应需要执行的函数,因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载,因为该实参是5,为int类型,所以要调用virtual void f(int a)函数,因为该f(int a)是一个虚函数,所以再去判断pBase所指向的具体对象,具体对象为Derived子类,再去Derived子类的虚函数表中找到void f(int a)函数。因为Derived子类继承了父类Base的虚函数vitural void f(int a),所以输出 virtual Base::f(int a);

在调用pBase->f(3.5)时,首先要去pBase类中找到对应需要执行的函数,因为因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载,因为该实参是3.5,为double类,所以要调用void f(double d)函数,因为该函数是一个普通成员函数,故直接输出。 void Base::f(double d);

再举一个例子:

  1. #include <iostream>  
  2. using namespace std;  
  3.  
  4. class Base  
  5. {  
  6. public:  
  7.     virtual void f(int a) {  
  8.         cout << "virtual Base::f(int a)" << endl;  
  9.     }  
  10.  
  11.     void f(double d) {  
  12.         cout << "Base::f(double d)" << endl;   
  13.     }  
  14. };  
  15.  
  16. class Derived : public Base  
  17. {  
  18. public:  
  19.  
  20.     void f(int a) {  
  21.         cout << "virtual Derived::f(int a)" << endl;  
  22.     }  
  23. };  
  24.  
  25. int main()  
  26. {  
  27.     Derived d;  
  28.     d.f(3);  
  29.     d.f(2.5);  
  30.  
  31.     Derived *pd = new Derived();  
  32.     pd->f(3);  
  33.     pd->f(2.5);  
  34.  
  35.     Base b;  
  36.     b.f(5);  
  37.     b.f(3.5);  
  38.  
  39.     Base *pBase = new Derived();  
  40.     pBase->f(5);  
  41.     pBase->f(3.5);  
  42. }  
  43.  
  44. #include <iostream> 
  45. using namespace std; 
  46.  
  47. class Base 
  48. public
  49.  virtual void f(int a) { 
  50.   cout << "virtual Base::f(int a)" << endl; 
  51.  } 
  52.  
  53.  void f(double d) { 
  54.   cout << "Base::f(double d)" << endl; 
  55.  } 
  56. }; 
  57.  
  58. class Derived : public Base 
  59. public
  60.  
  61.  void f(int a) { 
  62.   cout << "virtual Derived::f(int a)" << endl; 
  63.  } 
  64. }; 
  65.  
  66. int main() 
  67.  Derived d; 
  68.  d.f(3); 
  69.  d.f(2.5); 
  70.  
  71.  Derived *pd = new Derived(); 
  72.  pd->f(3); 
  73.  pd->f(2.5); 
  74.  
  75.  Base b; 
  76.  b.f(5); 
  77.  b.f(3.5); 
  78.  
  79.  Base *pBase = new Derived(); 
  80.  pBase->f(5); 
  81.  pBase->f(3.5); 

子类Derived中的void f(int a)既覆盖了基类Base的虚函数virtual void f(int a),也隐藏了基类的virtual void f(int a),  void f(double d)函数。

  1. Derived d;  
  2. d.f(3);  
  3. d.f(2.5);  
  4.  
  5. Derived *pd = new Derived();  
  6. pd->f(3);  
  7. pd->f(2.5);  
  8.  
  9. Derived d; 
  10. d.f(3); 
  11. d.f(2.5); 
  12.  
  13. Derived *pd = new Derived(); 
  14. pd->f(3); 
  15. pd->f(2.5); 

同理所有用子类对象或者子类指针来调用f()函数时,都只执行virtual void f(int a),输出virtual Derived::f(int a)

  1. view plaincopyprint?Base *pBase = new Derived();  
  2. pBase->f(5);  
  3. pBase->f(3.5);  
  4.  
  5. Base *pBase = new Derived(); 
  6. pBase->f(5); 
  7. pBase->f(3.5); 

pBase->f(5),首先去Base类中寻找相应的函数,同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数,因为实参为5,为int类型,所以我们要调用virtual void f(int a)虚函数,因为该函数是虚函数,所以要去判断pBase指向的具体对象,因为pBase指向的是一个子类的对象,所以需要去子类的虚函数表中取找virtual void f(int a)函数,找到之后,执行该函数,故输出virtual Derived::f(int a)。

pBase->f(3.5),首先去Base类中寻找相应的函数,同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数,因为实参为3.5,为double类型,所以我们要调用void f(double d),因为该函数为普通成员函数,故执行输出: void Base::f(double d);

【责任编辑:seeker TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

Struts 2权威指南:基于WebWork核心的MVC开发

本书所介绍的Struts 2已经完全超出了Struts 1框架原有的高度,Struts 2建立在Struts 1和WebWork两个框架整合的基础之上,因此提供了更多优...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊