转 重载、隐藏和覆盖的区别

类成员函数的重载、覆盖和隐藏区别？

答案：
a.成员函数被重载的特征：
（1）相同的范围（比如在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

隐藏破坏了多态性，因此一般要将隐藏换成覆盖。

重载，覆盖，隐藏的区别

成员函数的重载，覆盖，隐藏

（1）成员函数被重载的特征：相同的类范围，函数名字相同，参数不同，virtual 关键字可有可无。

（2）覆盖指派生类的函数覆盖基类函数，特征是分别位于基类和派生类，函数名字相同，参数相同，基类函数必须有virtual关键字

（3）隐藏是指派生类的函数屏蔽了与其同名的基类函数。1，派生类的函数与基类的函数同名，但是参数不同，

不论有无virtual关键字，基类的函数将被隐藏 2，派生类的函数与基类的函数同名，并且参数也相同，

但是基类函数没有virtual 关键字。此时，基类的函数被隐藏

3种情况怎么执行：重载：看参数；隐藏：用什么就调用什么；覆盖：调用派生类 。

 1 class A
 2 {
 3 public:
 4 static int a;
 5 static void fun()
 6 {
 7 cout<<"A::static void fun()"<<endl;
 8 }
 9 
10 
11 virtual void fun1()
12 {
13 cout<<"A::virtual void fun1()"<<endl;
14 }
15 
16 
17 virtual void fun2(int a)
18 {
19 cout<<"A::virtual void fun2(int) :"<<a<<endl;
20 }
21 
22   void fun3(int a)
23 {
24 cout<<"A::void fun3(int) : "<<a<<endl;
25 }
26 
27 
28 };
29 class B : public A
30 {
31 public:
32 int b;
33 void fun1()       //覆盖基类的函数
34 {
35 cout<<"B::void fun1()"<<endl;
36 }
37 void fun2(double a)    //重载基类的函数
38 {
39 cout<<"B::virtual void fun2(double) :"<<a<<endl;
40 }
41 void fun3(int a)     //隐藏基类的函数
42 {
43 cout<<"B::void fun3(int) :"<<a<<endl;
44 }
45 };
46 int A::a = 3;
47 int main()
48 {
49 A::fun();
50 A *a = new B();
51 cout<<"通过基类指针访问成员函数：－－－－－－－－－"<<endl;
52 a->fun1();
53 a->fun2(3);
54 a->fun2(3.14);
55 a->fun3(5);
56 B *b = new B();
57 cout<<"通过子类指针访问成员函数：－－－－－－－－－"<<endl;
58 b->fun();
59 b->fun1();
60 b->fun2(3);
61 b->fun2(3.14);
62 b->fun3(5);
63 return 0;
64 }
65 
66 结果输出为：
67 /* 
68  *::static void fun()
69  通过基类指针访问成员函数：－－－－－－－－－
70  B::void fun1()
71  A::virtual void fun2(int) :3
72  A::virtual void fun2(int) :3
73  A::void fun3(int) : 5
74  通过子类指针访问成员函数：－－－－－－－－－
75  A::static void fun()
76  B::void fun1()
77  B::virtual void fun2(double) :3
78  B::virtual void fun2(double) :3.14
79  B::void fun3(int) :5
80  * */

总结：

1，覆盖，也就是多态，基类函数名，参数与子类函数名，参数一致，基类函数为虚函数，访问的是子类的函数。

2，重载，函数名相同，参数不同，不管是不是虚函数。用什么类型的指针或引用访问的就是什么类型的函数，例如用基类指针指向子类类型，但用其访问基类和子类同名函数时，则访问的就是基类的函数，尽管调用的函数的参数与子类函数相同与基类不同，但也会转换为基类函数的参数类型，还是调用子类的函数。

3，隐藏，函数名和参数全相同，且基类函数不为虚函数。则不管基类指针指向的是基类类型还是子类类型，基类指针还是访问的是基类函数。即用什么类型指针或引用就访问什么类型的函数，与上面的相似。