C++中成员函数的重载、覆盖和隐藏

参考博客：点击打开链接

重载与覆盖的区别
1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系。
2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
3、覆盖要求参数列表相同；重载要求参数列表不同。
4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
override可以翻译为覆盖，从字面就可以知道，它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点：
    1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果；
    2、覆盖的方法的返回值必须和被覆盖的方法的返回一致；
    3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类；
    4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
     overload对我们来说可能比较熟悉，可以翻译为重载，它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点：
    1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int, float)， 但是不能为fun(int, int)）；
    2、不能通过访问权限、返回类型、抛出的异常进行重载；
    3、方法的异常类型和数目不会对重载造成影响；
   overload编译时的多态   
   override运行时的多态
面向对象程序设计中的另外一个重要概念是多态性。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。可以把一组对象放到一个数组中，然后调用它们的方法，在这种场合下，多态性作
用就体现出来了，这些对象不必是相同类型的对象。当然，如果它们都继承自某个类，你可以把这些派生类，都放到一个数组中。如果这些对象都有同名方法，就可以调用每个对象的同名方法。
同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。多态性通过派生类重载基类中的虚函数型方法来实现。
在面向对象的系统中，多态性是一个非常重要的概念，它允许客户对一个对象进行操作，由对象来完成一系列的动作，具体实现哪个动作、如何实现由系统负责解释。
“多态性”一词最早用于生物学，指同一种族的生物体具有相同的特性。在C#中，多态性的定义是：同一操作作用于不同的类的实例，不同的类将进行不同的解释，最后产生不同的执行结果。C#支持两种类型的多态性：
● 编译时的多态性
编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。
● 运行时的多态性
运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。
编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

1、类成员函数的重载、重写、和覆盖区别

    a.成员函数被重载的特征：

     （1）相同的范围（在同一个类中）；

     （2）函数名字相同；

     （3）参数不同（重载函数的主要特征）；

     （4）virtual关键字可有可无；

     （5）不受返回值影响。

    b.覆盖是指派生类函数覆盖基类函数，特征是：

     （1）不同的范围（分别位于派生类与基类）；

     （2）函数名字相同；

     （3）参数相同；

     （4）基类函数必须有virtual关键字。

    c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

     （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

     （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

2、"隐藏"实例分析

[html]  view plain copy

1. #include "stdafx.h"  
2. #include <iostream.h>  
3. #include <string.h>  
4.   
5. class A  
6. {  
7. public:  
8.     void hello(){cout<<"A hello"<<endl;}  
9.     virtual void hello(int i){cout<<"A hello int"<<endl;}  
10. };  
11.   
12. class B:public A  
13. {  
14. public:  
15.     void hello() const{cout<<"B hello"<<endl;} //B中的hello()隐藏了A中的hello(int)  
16. };  
17.   
18. //重载时的隐藏问题,解决办法，在B中重新定义hello(int)函数  
19. void main()  
20. {  
21.     B b;  
22.     b.hello();  
23. //  b.hello(1);  //error  
24. }  

3、虚函数实例分析1

[html]  view plain copy

1. #include "stdafx.h"  
2. #include <iostream.h>  
3. #include <string.h>  
4.   
5. class A  
6. {  
7. protected:  
8.     int i;  
9. public:  
10.     A(int d=0){i=d;}  
11.     int GetData(){return doGetData();}  
12.     virtual int doGetData(){return i;}       //虚函数  
13. };  
14.   
15. class B:public A  
16. {  
17. protected:  
18.     int i;  
19. public:  
20.     B(int d=1){i=d;}  
21.     int doGetData(){return i;}        
22. };  
23.   
24. class C:public B  
25. {  
26. protected:  
27.     int i;  
28. public:  
29.     C(int d=2){i=d;}  
30. };  
31.   
32. void main()  
33. {  
34.     C c(10);  
35.   
36.     /* B和的C对象调用一般成员函数GetData()都是调用的A类中的GetData()，因为A中的doGetData()是虚函数，所以调用B类中的doGetData() */  
37.     /* B和的C对象调用虚函数doGetData()都是调用的B类中的重定义的doGetData()，除非显示指定调用哪个类的虚函数  */  
38.   
39.     cout<<c.GetData()<<" ";        /*  本来要调用C的GetData(),C中未定义，故调用B中的，但是B中也未定义，故调用A的GetData(),因为A中的doGetData()是虚函数，所以调用B中的doGetData()，返回B::i */  
40.     cout<<c.A::GetData()<<" ";        
41.     cout<<c.B::GetData()<<" ";  
42.     cout<<c.C::GetData()<<" ";  
43.   
44.     cout<<c.doGetData()<<" ";      /*  调用B类中的doGetData() */  
45.     cout<<c.A::doGetData()<<" ";   /*  直接调用A类中的doGetData() */  
46.     cout<<c.B::doGetData()<<" ";   /*  直接调用B类中的doGetData() */  
47.     cout<<c.C::doGetData()<<endl;  /*  因为C没有重定义doGetData(),所有调用B中的doGetData()*/  
48.   
49.     //答案：1 1 1 1 1 0 1 1  
50. }  

4、虚函数实例分析2

[html]  view plain copy

1. #include "stdafx.h"  
2. #include <iostream.h>  
3. #include <string.h>  
4.   
5. class A  
6. {  
7. public:  
8.     virtual void display(){cout<<"A"<<endl;}       //虚函数  
9. };  
10.   
11. class B:public A  
12. {  
13. public:  
14.     virtual void display(){cout<<"B"<<endl;}       //虚函数     
15. };  
16.   
17. void main()  
18. {  
19.     A *pa=new A;  
20.     pa->display();     //调用A中的虚函数  
21.     B *pb=(B*)pa;      //pb指向pa，而pa始终指向A的对象，故调用A中的虚函数  
22.     pb->display();  
23.   
24.     delete pa,pb;  
25.   
26.     pa=new B;  
27.     pa->display();     //调用B中的虚函数  
28.     pb=(B*)pa;         //pb指向pa，pa始终指向B的对象，故调用B中的虚函数  
29.     pb->display();  
30. }  

5、虚继承分析

[html]  view plain copy

1. #include "stdafx.h"  
2. #include <iostream.h>  
3. #include <string.h>  
4.   
5. class A  
6. {  
7.     char a[3];  
8. public:  
9.     virtual void display1(){}       //虚函数  
10. };  
11.   
12. class B:public virtual A  //虚继承  
13. {  
14.     char b[3];  
15. public:  
16.     virtual void display2(){}       //虚函数     
17. };  
18.   
19. class C:public virtual B  //虚继承  
20. {  
21.     char c[3];  
22. public:  
23.     virtual void display3(){}       //虚函数     
24. };  
25.   
26. void main()  
27. {  
28.     cout<<sizeof(A)<<" ";  //8    char a[3]、虚指针  
29.     cout<<sizeof(B)<<" ";  //20   char b[3]、虚指针、虚继承的指针、父类  
30.     cout<<sizeof(C)<<endl; //32   char c[3]、虚指针、虚继承的指针、父类  
31. }