自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

C++ 成員函數(shù)的重載，繼承，覆蓋和隱藏

作者：2cto
開發(fā) 后端
在調(diào)用pBase->f(5)時(shí)，首先要去pBase類中找到對(duì)應(yīng)需要執(zhí)行的函數(shù)，因?yàn)锽ase類中有兩個(gè)函數(shù)virtual void f(int a) 和 void f(double)重載，因?yàn)樵搶?shí)參是5，為int類型，所以要調(diào)用virtual void f(int a)函數(shù)，因?yàn)樵揻(int a)是一個(gè)虛函數(shù)，所以再去判斷pBase所指向的具體對(duì)象，具體對(duì)象為Derived子類，再去Derived子類的虛函數(shù)表中找到void f(int a)函數(shù)

一、 C++成員函數(shù)的重載

C++中的成員函數(shù)有四種，分別是普通成員函數(shù)，virtual虛函數(shù)，const成員函數(shù)。

  • (1) void func(int a);

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

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

如果在一個(gè)類中，聲明這四種函數(shù)，哪是重復(fù)定義？哪些是重載？

其中(1)(2)是重復(fù)定義，故編譯不能通過(guò)，而(3)與(1)(2)是不同類型的函數(shù)，是重載。

成員函數(shù)被重載的特征是：

  • (1)具有相同的作用域(即同一個(gè)類定義中)；

  • (2)函數(shù)名字相同

  • (3)參數(shù)類型，順序 或 數(shù)目不同(包括const參數(shù)和非const函數(shù))

  • (4)virtual關(guān)鍵字可有可無(wú)。

從成員函數(shù)的重載特征中，可以知道(1)(2)是重復(fù)定義。那么(3)為什么和(1)(2)不同呢？

因?yàn)轭愔械暮瘮?shù)，都會(huì)自動(dòng)添加一個(gè)自身類指針this，所以

 

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

所以(3)可以與(1)(2)發(fā)生重載，因?yàn)閰?shù)有一個(gè)const。

二 、C++成員函數(shù)的繼承

 

  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. { 
  49. public: 
  50.  void h(int a) { 
  51.   cout << "Derivd::h(int a)" << endl; 
  52.  } 
  53. }; 
  54.  
  55. int main() 
  56. { 
  57.  Base b; 
  58.  b.f(3); 
  59.  b.g(4); 
  60.  
  61.  Derived d; 
  62.  d.f(3); 
  63.  d.g(4); 
  64.  d.h(3); 
  65. } 

 

Base b的對(duì)象模型：

Derived d的對(duì)象模型：

則在子類Derived d中繼承了父類中的virtual void g(int a) ; void f(int a);

運(yùn)行結(jié)果為：

三、C++成員函數(shù)的覆蓋

覆蓋是指派生類重新實(shí)現(xiàn)(或者改寫)了基類的成員函數(shù)，其特征是：

  • (1)不同的作用域(非別位于派生類和基類中)；

  • (2)函數(shù)名稱相同

  • (3)參數(shù)列表完全相同；

  • (4)基類函數(shù)必須是虛函數(shù)。

從(4)中我們得知覆蓋只是針對(duì)虛函數(shù)的。

 

  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. { 
  52. public: 
  53.  void h(int a) { 
  54.   cout << "Derivd::h(int a)" << endl; 
  55.  } 
  56.  virtual void g(int a) { 
  57.   cout << "virtual Derived::g(int a)" << endl; 
  58.  } 
  59. }; 
  60.  
  61. int main() 
  62. { 
  63.  Base b; 
  64.  b.f(3); 
  65.  b.g(4); 
  66.  
  67.  Derived d; 
  68.  d.f(3); 
  69.  d.g(4); 
  70.  d.h(3); 
  71. } 

 

Derived d對(duì)象模型如下：

其中Derived中重新定義了基類的虛成員函數(shù)virtual void g(int a)；

四、C++成員函數(shù)的隱藏

隱藏是指派生類的成員函數(shù)遮蔽了與其同名的基類成員函數(shù)，具體規(guī)則如下：

(1) 派生類的函數(shù)與基類的函數(shù)同名，但是參數(shù)列表有所差異。此時(shí)，不論有無(wú)virtual關(guān)鍵字，基類的函數(shù)在派生類中將被隱藏。(注意別與重載混合)

(2)派生類的函數(shù)與基類的函數(shù)同名，參數(shù)列表也相同，但是基類函數(shù)沒(méi)有virtual關(guān)鍵字。此時(shí)，基類的函數(shù)在派生類中將被吟唱。(注意別與覆蓋混合)

判斷下面哪些函數(shù)是覆蓋，哪些函數(shù)是隱藏？

 

  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. { 
  77.  Derived d; 
  78.  Base *pb = &d; 
  79.  Derived *pd = &d; 
  80.  
  81.  pb->f(3.14f); 
  82.  pd->f(3.14f); 
  83.  
  84.  pb->g(3.14f); 
  85.  pd->g(3.14f); 
  86.  
  87.  pb->h(3.14f); 
  88.  pd->h(3.14f); 
  89. } 

 

其中子類Derived中 vitual void f(float x)  是覆蓋，而void g(int x) 和void h(float x)都是隱藏。

運(yùn)行結(jié)果：

再看一個(gè)例子：

 

  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. { 
  49. public: 
  50.  virtual void f(int a) { 
  51.   cout << "virtual Base::f(int a)" << endl; 
  52.  } 
  53.  
  54.  void f(double d) { 
  55.   cout << "Base::f(double d)" << endl; 
  56.  } 
  57. }; 
  58.  
  59. class Derived : public Base 
  60. { 
  61. public: 
  62.  
  63.  void f(double d) { 
  64.   cout << "Derivd::f(double d)" << endl; 
  65.  } 
  66. }; 
  67.  
  68. int main() 
  69. { 
  70.  Derived d; 
  71.  d.f(3); 
  72.  d.f(2.5); 
  73.  
  74.  Derived *pd = new Derived(); 
  75.  pd->f(3); 
  76.  pd->f(2.5); 
  77.  
  78.  Base b; 
  79.  b.f(5); 
  80.  b.f(3.5); 
  81.  
  82.  Base *pBase = new Derived(); 
  83.  pBase->f(5); 
  84.  pBase->f(3.5); 
  85. } 

 

其中父類中的void f(double d)隱藏了子類的virtual void f(int a),  void f(double d)函數(shù)。

所以在主函數(shù)中

 

  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);只要通過(guò)Derived對(duì)象或者Derived指針執(zhí)行f()函數(shù)，都只執(zhí)行void Derived::f(double d)該函數(shù)。 
  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); 

 

在調(diào)用pBase->f(5)時(shí)，首先要去pBase類中找到對(duì)應(yīng)需要執(zhí)行的函數(shù)，因?yàn)锽ase類中有兩個(gè)函數(shù)virtual void f(int a) 和 void f(double)重載，因?yàn)樵搶?shí)參是5，為int類型，所以要調(diào)用virtual void f(int a)函數(shù)，因?yàn)樵揻(int a)是一個(gè)虛函數(shù)，所以再去判斷pBase所指向的具體對(duì)象，具體對(duì)象為Derived子類，再去Derived子類的虛函數(shù)表中找到void f(int a)函數(shù)。因?yàn)镈erived子類繼承了父類Base的虛函數(shù)vitural void f(int a)，所以輸出 virtual Base::f(int a);

在調(diào)用pBase->f(3.5)時(shí)，首先要去pBase類中找到對(duì)應(yīng)需要執(zhí)行的函數(shù)，因?yàn)橐驗(yàn)锽ase類中有兩個(gè)函數(shù)virtual void f(int a) 和 void f(double)重載，因?yàn)樵搶?shí)參是3.5，為double類，所以要調(diào)用void f(double d)函數(shù)，因?yàn)樵摵瘮?shù)是一個(gè)普通成員函數(shù)，故直接輸出。 void Base::f(double d);

再舉一個(gè)例子：

 

  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. { 
  49. public: 
  50.  virtual void f(int a) { 
  51.   cout << "virtual Base::f(int a)" << endl; 
  52.  } 
  53.  
  54.  void f(double d) { 
  55.   cout << "Base::f(double d)" << endl; 
  56.  } 
  57. }; 
  58.  
  59. class Derived : public Base 
  60. { 
  61. public: 
  62.  
  63.  void f(int a) { 
  64.   cout << "virtual Derived::f(int a)" << endl; 
  65.  } 
  66. }; 
  67.  
  68. int main() 
  69. { 
  70.  Derived d; 
  71.  d.f(3); 
  72.  d.f(2.5); 
  73.  
  74.  Derived *pd = new Derived(); 
  75.  pd->f(3); 
  76.  pd->f(2.5); 
  77.  
  78.  Base b; 
  79.  b.f(5); 
  80.  b.f(3.5); 
  81.  
  82.  Base *pBase = new Derived(); 
  83.  pBase->f(5); 
  84.  pBase->f(3.5); 
  85. } 

 

子類Derived中的void f(int a)既覆蓋了基類Base的虛函數(shù)virtual void f(int a)，也隱藏了基類的virtual void f(int a),  void f(double d)函數(shù)。

 

  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); 

 

同理所有用子類對(duì)象或者子類指針來(lái)調(diào)用f()函數(shù)時(shí)，都只執(zhí)行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類中尋找相應(yīng)的函數(shù)，同理Base類中的兩個(gè)函數(shù)virtual void f(int a)和void f(double d)是重載函數(shù)，因?yàn)閷?shí)參為5,為int類型，所以我們要調(diào)用virtual void f(int a)虛函數(shù)，因?yàn)樵摵瘮?shù)是虛函數(shù)，所以要去判斷pBase指向的具體對(duì)象，因?yàn)閜Base指向的是一個(gè)子類的對(duì)象，所以需要去子類的虛函數(shù)表中取找virtual void f(int a)函數(shù)，找到之后，執(zhí)行該函數(shù)，故輸出virtual Derived::f(int a)。

pBase->f(3.5),首先去Base類中尋找相應(yīng)的函數(shù)，同理Base類中的兩個(gè)函數(shù)virtual void f(int a)和void f(double d)是重載函數(shù)，因?yàn)閷?shí)參為3.5,為double類型，所以我們要調(diào)用void f(double d)，因?yàn)樵摵瘮?shù)為普通成員函數(shù)，故執(zhí)行輸出： void Base::f(double d);

責(zé)任編輯：張燕妮 來(lái)源： 2cto
C++函數(shù)覆蓋
相關(guān)推薦

2009-05-26 09:31:00

C++重載覆蓋

2020-06-17 12:22:44

C覆蓋重載

2010-01-18 16:56:30

C++函數(shù)

2010-01-20 17:48:07

C++ 函數(shù)重載

2010-02-05 15:59:26

C++函數(shù)重載

2010-01-21 14:28:03

C++靜態(tài)成員函數(shù)

2011-07-20 17:16:50

C++重載函數(shù)

2025-01-26 16:01:13

C++靜態(tài)成員函數(shù)

2010-02-04 09:26:23

C++模板函數(shù)重載

2010-01-11 15:21:18

C++語(yǔ)言

2021-06-18 12:30:36

C++函數(shù)指針編程語(yǔ)言

2009-09-04 17:34:11

C#CC++

2011-07-12 11:15:46

C++

2010-02-02 15:01:59

C++成員函數(shù)指針

2011-07-20 16:09:08

C++

2010-02-04 10:08:00

C++靜態(tài)成員函數(shù)

2009-08-25 17:15:50

C#隱藏C#重寫C#重載

2009-07-31 16:06:50

成員函數(shù)構(gòu)造函數(shù)C#

2010-01-21 13:48:30

C++基類

2023-04-03 07:08:28

C++函數(shù)模板
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號(hào)