C++类成员函数的重载、覆盖与隐藏

成员函数的重载、覆盖（override）与隐藏很容易混淆，C++程序员必须要搞清楚概念，否则错误将防不胜防。

一.函数重载

1.重载的原因：

在 C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，即函数重载。 这样便于记忆，提高了函数的易用性，这是 C++语言采用重载机制的一个理由。

例如下面例子中的函数 EatBeef,EatFish,EatChicken可以用同一个函数名 Eat 表示，用不同类型的参数加以区别。

void EatBeef(…); // 可以改为 void Eat(Beef …); 
void EatFish(…); // 可以改为 void Eat(Fish …); 
void EatChicken(…); // 可以改为 void Eat(Chicken …); 

C++语言采用重载机制的另一个理由是：类的构造函数需要重载机制。因为 C++规定构造函数与类同名，构造函数只能有一个名字。如果想用几种不同的方法创建对象该怎么办？别无选择，只能用重载机制来实现。所以类可以有多个同名的构造函数。

2.重载是如何实现的？

几个同名的重载函数仍然是不同的函数，它们是如何区分的呢？

我们自然想到函数接口的两个要素：参数与返回值。 如果同名函数的参数不同（包括类型、顺序不同），那么容易区别出它们是不同的函数。 如果同名函数仅仅是返回值类型不同，有时可以区分，有时却不能。例如：

void Function(void);  
int Function (void);  

上述两个函数，第一个没有返回值，第二个的返回值是 int 类型。如果这样调用函数： int x = Function (); 则可以判断出 Function 是第二个函数。问题是在C++/C 程序中，我们可以忽略函数的返回值。在这种情况下，编译器和程序员都不知道哪个 Function 函数被调用。 所以只能靠参数而不能靠返回值类型的不同来区分重载函数。

编译器根据参数为每个重载函数产生不同的内部标识符。例如编译器为上例中的三个 Eat 函数产生象_eat_beef、_eat_fish、_eat_chicken 之类的内部标识符（不同的编译器可能产生不同风格的内部标识符）。

二.函数覆盖

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

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

（2）函数名字相同；

（3）参数不同；

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

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

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

（2）函数名字相同；

（3）参数相同；

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

/*
  函数Base::f(int)与Base::f(float)相互重载；
  而Base::g(void)被Derived::g(void)覆盖。
*/
#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;}
};

void main(void)
{
    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)
}

三.函数隐藏

1.令人疑惑的隐藏规则

本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。

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

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

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

下面示例程序中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

#include <iostream>
using namespace std;
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; }
};

很多 C++程序员没有意识到有“隐藏”这回事。由于认识不够深刻， “隐藏”的发生可谓神出鬼没，常常产生令人迷惑的结果。 下面例子中 ，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   (surprise!!!)
    
    // Bad : behavior depends on type of the pointer
    pb->h(3.14f); // Base::h(float) 3.14   (surprise!!!)
    pd->h(3.14f); // Derived::h(float) 3.14
}

2.摆脱隐藏

隐藏规则引起了不少麻烦。下例程序中，语句 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
}

从上例看来，隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由：

• 写语句 pd->f(10)的人可能真的想调用 Derived::f(char *)函数，只是他误将参数写错了。有了隐藏规则，编译器就可以明确指出错误，这未必不是好事。否则，编译器会静悄悄地将错就错，程序员将很难发现这个错误，流下祸根。

• 假如类 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); }  
  };