面向对象中的重载、覆盖和隐藏

 1.重载是一个类内部实现相同机理的操作，但是操作的对象不同。主要体现在：

1.  方法在同一个类中
2. 重载的方法名称相同
3. 参数不同（参数的类型不同，参数的个数不同）
4. virtual关键字可有可无

    下面的代码对上面的说明进行解释：

    

[cpp]  view plain  copy

 

1. #include "stdafx.h"  
2. #include<iostream>  
3.   
4. using namespace std;  
5.   
6. class  father  
7. {  
8. public:  
9.      void DoJob(int a);  
10.      void DoJob(double a);  
11.      void DoJob(int a, int b);  
12.      void DoJob(int a, int b, int c);  
13.     ~ father();  
14.   
15. private:  
16.   
17. };  
18. void father::DoJob(int a)  
19. {  
20.     cout << "one parameter:" << a << endl;  
21. }  
22. void::father::DoJob(double a)  
23. {  
24.     cout << "one double parameter:" << a << endl;  
25. }  
26. void father::DoJob(int a, int b)  
27. {  
28.     cout << "two parameter: " << a << "  and  " << b << endl;  
29. }  
30. void father::DoJob(int a, int b, int c)  
31. {  
32.     cout << "three parameter:" << a << "  and  " << b << "  and  " << c << endl;  
33. }  
34.    
35.   
36.  father::~ father()  
37. {  
38. }  
39.   
40.    
41. int _tmain(int argc, _TCHAR* argv[])  
42. {  
43.     father f;  
44.     f.DoJob(4);  
45.     f.DoJob(4.3);  
46.     f.DoJob(5, 6);  
47.     f.DoJob(4, 5, 6);  
48.     return 0;  
49. }  

    father类的DoJob方法实现了重载，其中既有参数类型不同的重载，也有参数个数不同的重载。

2.覆盖，就是面向对象中的多态，是子类的方法覆盖了基类的方法，以实现不同的功能，或者对父类的功能进行扩充。主要体现在：

1. 派生类函数覆盖基类函数
2. 不同的范围（分别位于派生类和基类中）
3. 函数名称相同
4. 参数相同
5. 基类函数必须有virtual关键字

下面的代码对上面的说明进行解释：

[cpp]  view plain  copy

 

1. #include "stdafx.h"  
2. #include<iostream>  
3.   
4. using namespace std;  
5.   
6. class  father  
7. {  
8. public:  
9.      virtual void DoJob(int a);    
10.     ~ father();  
11.   
12. private:  
13.   
14. };  
15. void father::DoJob(int a)  
16. {  
17.     cout << "one parameter in base class:" << a << endl;  
18. }  
19.   
20.   
21.  father::~ father()  
22. {  
23. }  
24.   
25.  class son :public father  
26.  {  
27.  public:  
28.      void DoJob(int a);  
29.      ~son();  
30.  };  
31.  void son::DoJob(int a)  
32.  {  
33.      cout << "one parameter in son class:" << a << endl;  
34.  }  
35.  son::~son()  
36.  {}  
37. int _tmain(int argc, _TCHAR* argv[])  
38. {  
39.     son s;  
40.     father *f = &s;  
41.     f->DoJob(5);  
42.       
43.     return 0;  
44. }  

上述代码的运行结果为：

上面的代码中子类son中的函数DoJob（）对父类father中的函数DoJob（）进行了覆盖。

3.隐藏是派生类的函数屏蔽了与其同名的基类函数。其特点主要体现在：

1. 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数都将被覆盖。
2. 如果派生类的函数与基类的函数同门，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数也将被隐蔽。还记得吗如果此时基类函数如果有virtual，子类函数就覆盖了父类函数。 

以下的代码对上面的说明进行解释：

[cpp]  view plain  copy

 

1. #include "stdafx.h"  
2. #include<iostream>  
3.   
4. using namespace std;  
5.   
6. class  father  
7. {  
8. public:  
9.      virtual void DoJob(int a);    
10.      virtual void DoJob(int a, int b);  
11.     ~ father();  
12.   
13. private:  
14.   
15. };  
16. void father::DoJob(int a)  
17. {  
18.     cout << "one parameter in base class:" << a << endl;  
19. }  
20.   
21. void father::DoJob(int a, int b)  
22. {  
23.     cout << "two parameter in base class:" << a << "  and  " << b << endl;  
24. }  
25.  father::~ father()  
26. {  
27. }  
28.   
29.  class son :public father  
30.  {  
31.  public:  
32.      void DoJob(double a);  
33.      ~son();  
34.  };  
35.  void son::DoJob(double a)  
36.  {  
37.      cout << "one parameter in son class:" << a << endl;  
38.  }  
39.  son::~son()  
40.  {}  
41. int _tmain(int argc, _TCHAR* argv[])  
42. {  
43.     son s;  
44.     s.DoJob(1);  
45.     s.DoJob(2, 3);  
46.     return 0;  
47. }  

对上面的代码进行编译，会出现错误：

    error C2660: “son::DoJob”: 函数不接受 2 个参数，这就说明基类father中的DoJob(int a,int b)函数被隐藏了。

网址：http://blog.csdn.net/longshengguoji/article/details/17691913