c++中的重载，覆盖和隐藏

1 重载

成员函数被重载的特征有：
1) 相同的范围（在同一个类中）；
2) 函数名字相同；
3) 参数不同；
4) virtual关键字可有可无。

在 同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制叫重载， 重载不关心函数的返回值类型。例如在同一可访问区内有：
① double calculate(double);
② double calculate(double，double);
③ double calculate(double, int);
④ double calculate(int, double);
⑤ double calculate(int);
⑥ float calculate(float);
⑦ float calculate(double);
六个同名函数calculate，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，而①和⑦却不能构成重载，因为①和⑦的参数相同。

2 覆盖
覆盖的特征有：
1) 不同的范围（分别位于派生类与基类）；
2) 函数名字相同；
3) 参数相同；
4) 基类函数必须有virtual关键字。

比如，在下面的程序中：

#include <iostream.h>class Base{public:void f(int x){ cout << "Base::f(int) " << x << endl; }void f(float x){ cout << "Base::f(float) " << x << endl; }virtual void g(void){ cout << "Base::g(void)" << endl;}};class Derived : public Base{public:virtual void g(void){ cout << "Derived::g(void)" << endl;}};void main(void){Derived d;Base *pb = &d;pb->f(42); // 运行结果: Base::f(int) 42pb->f(3.14f); // 运行结果: Base::f(float) 3.14pb->g(); // 运行结果: Derived::g(void)}

函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。

3 隐藏
隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
1) 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

比如，在下面的程序中：

#include <iostream.h>class Base{public:virtual void f(float x){ cout << "Base::f(float) " << x << endl; }void g(float x){ cout << "Base::g(float) " << x << endl; }void h(float x){ cout << "Base::h(float) " << x << endl; }};class Derived : public Base{public:virtual void f(float x){ cout << "Derived::f(float) " << x << endl; }//被继承之后,virtual 可有可无，但最好有。继承后，还是虚函数。void g(int x){ cout << "Derived::g(int) " << x << endl; }void h(float x){ cout << "Derived::h(float) " << x << endl; }using Base::g;//这句话是用来引用父类中被隐藏的部分的。};

1) 函数Derived::f(float)覆盖了Base::f(float)。
2) 函数Derived::g(int)隐藏了Base::g(float)，注意，不是重载。
3) 函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

4 实例分析

void main(void){Derived d;Base *pb = &d;Derived *pd = &d;// Good: behavior depends solely on type of the objectpb->f(3.14f); //运行结果: Derived::f(float) 3.14pd->f(3.14f); //运行结果: Derived::f(float) 3.14// Bad : behavior depends on type of the pointerpb->g(3.14f); //运行结果: Base::g(float) 3.14pd->g(3.14f); //运行结果: Derived::g(int) 3// Bad : behavior depends on type of the pointerpb->h(3.14f); //运行结果: Base::h(float) 3.14pd->h(3.14f); //运行结果: Derived::h(float) 3.14}

f()函数属于覆盖，而g()与h()属于隐藏。从上面的运行结果，我们可以注意到在覆盖中，用基类指针和派生类指针调用函数f() 时，系统都是执行的派生类函数f()，而非基类的f()，这样实际上就是完成的“接口”功能。而在隐藏方式中，用基类指针和派生类指针调用函数f()时， 系统会进行区分，基类指针调用时，系统执行基类的f()，而派生类指针调用时，系统“隐藏”了基类的f()，执行派生类的f()，这也就是“隐藏”的由 来。

class A {      public:            void show() {}; //编号1            void rose(int a) {}   //编号2 }; class B:public A {      public:            void show() {}; //编号3            void rose(int a, int b) {}; //编号4 };

类B中的show()和rose()明显是隐藏了类A的show()和rose()
编号1和编号2,在类B中哪怕存在,但只能通过类A的指针调用,而不能通过B类对象调用,如:

程序代码：

A *p = new B; p->show(); p->rose(3); p->rose(3,5); //error

编号3和编程4,只能通过类B对象调用,而不能通过类A的指针调用,如:

程序代码：

B b; b.show(); b.rose(3,5); b.rose(4); //error