函数重载、覆盖与隐藏

“overload”翻译过来就是：超载，过载，重载，超出标准负荷；“override”翻译过来是：重置，覆盖,使原来的失去效果。

先来说说重载的含义，在日常生活中我们经常要清洗一些东西，比如洗车、洗衣服。尽管我们说话的时候并没有明确地说用洗车的方式来洗车，或者用洗衣服的方式来洗一件衣服，但是谁也不会用洗衣服的方式来洗一辆车，否则等洗完时车早就散架了。我们并不要那么明确地指出来就心知肚明，这就有重载的意思了。在同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制叫重载，重载不关心函数的返回值类型。这里，“重载”的“重”的意思不同于“轻重”的“重”，它是“重复”、“重叠”的意思。例如在同一可访问区内有：

① 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，①②③④⑤⑥中任两个均构成重载，⑥和⑦也能构成重载，而①和⑦却不能构成重载，因为①和⑦的参数相同。
下面我们从成员函数的角度来讲述重载和覆盖的区别。

成员函数被重载的特征有：

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

2) 函数名字相同；

3) 参数不同；

4) virtual关键字可有可无。

覆盖的特征有：

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

2) 函数名字相同；

3) 参数相同；

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

比如，在下面的程序中：
#include <iostream>    
using namespace std;

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;}    
};    
    
int main(void)    
{    
    Base b;
    Derived d;    
    Base *pb = &d;    
    pb->f(42); // 运行结果: Base::f(int) 42    
    pb->f(3.14f); // 运行结果: Base::f(float) 3.14    
    pb->g(); // 运行结果: Derived::g(void)    

    pb = &b;
    pb->g(); // 运行结果: Base::g(void)    

    return 0;
}  

函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。
注意：这里pb指向继承类对象d,调用g()函数的的时候就是调用继承类函数。指向的对象的类，而不是指针的类决定调用哪个类的函数。覆盖看实例。

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

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

2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆，有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; }  
    void g(int x){ cout << "Derived::g(int) " << x << endl; }  
    void h(float x){ cout << "Derived::h(float) " << x << endl; }  
};


通过分析可得：
1) 函数Derived::f(float)覆盖了Base::f(float)。
2) 函数Derived::g(int)隐藏了Base::g(float)，注意，不是重载。
3) 函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。
看完前面的示例，可能大家还没明白隐藏与覆盖到底有什么区别，因为我们前面都是讲的表面现象，怎样的实现方式，属于什么情况。
下面我们就要分析覆盖与隐藏在应用中到底有什么不同之处。在下面的程序中bp和dp指向同一地址，按理说运行结果应该是相同的，可事实并非如此。
void main(void)  
{  
    Derived d;  
    Base *pb = &d;  
    Derived *pd = &d;  
      
    // Good : behavior depends solely on type of the object  
    pb->f(3.14f); //运行结果: Derived::f(float) 3.14   
    pd->f(3.14f); //运行结果: Derived::f(float) 3.14   
  
    // Bad : behavior depends on type of the pointer  
    pb->g(3.14f); //运行结果: Base::g(float) 3.14   
    pd->g(3.14f); //运行结果: Derived::g(int) 3    
  
    // Bad : behavior depends on type of the pointer  
    pb->h(3.14f); //运行结果: Base::h(float) 3.14   
    pd->h(3.14f); //运行结果: Derived::h(float) 3.14   
}

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

摆脱隐藏 
   隐藏规则引起了不少麻烦。以下示例程序中，语句pd->f(10)的本意是想调用函数Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隐藏了。由于数字10不能被隐式地转化为字符串，所以在编译时出错。 

class Base 
{ 
public: 
    void f(int x); 
};

class Derived : public Base 
{ 
public: 
    void f(char *str); 
};
void Test(void) 
{ 
    Derived *pd = new Derived; 
    pd->f(10);    // error 
}

看来，隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由：
1、写语句pd->f(10)的人可能真的想调用Derived::f(char *)函数，只是他误将参数写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编译器会静悄悄地将错就错，程序员将很难发现这个错误，流下祸根。
2、假如类Derived有多个基类（多重继承），有时搞不清楚哪些基类定义了函数f。如果没有隐藏规则，那么pd->f(10)可能会调用一个出乎意料的基类函数f。尽管隐藏规则看起来不怎么有道理，但它的确能消灭这些意外。
 
如果语句pd->f(10)一定要调用函数Base::f(int)，那么将类Derived修改为如下即可。 
class Derived : public Base 
{ 
public: 
    void f(char *str); 
    void f(int x) { Base::f(x); } 
};
（有些文章把本文中的覆盖也叫重载？）