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

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

重载与覆盖

成员函数被重载的特征：

1. 相同的范围（在同一个类中）
2. 函数名字相同
3. 参数不同（参数类型或参数个数）
4. virtual 关键字可有可无
5. const属性也可构成重载，返回值不能构成重载

覆盖是指派生类函数覆盖基类的virtual函数，特征是：

1. 不同的范围（分别位于派生类与基类）
2. 函数名字相同
3. 函数签名相同 （参数类型、参数个数、返回值类型均相同）
4. 基类函数必须有virtual 关键字

示例1：

#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() {
	Derived d;
	Base* pb = &d;

	d.f(42);		// Base::f(int) 42
	d.f(3.14f);		// Base::f(float) 3.14
	pb->g();		// Derived::g(void)

	return 0;
}

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

令人迷惑的隐藏规则

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

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

示例2：

#include <iostream>
using namespace std;

class Base
{
public:
	virtual void f(float x) { cout << "Base::f(float) " << x << endl; }
	virtual 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; }			//Base::g有virtual关键字，但是参数不同，构成隐藏，而不是重载
	void h(float x) { cout << "Derived::h(float) " << x << endl; }		//构成隐藏，而不是覆盖
};

int main() {
	Derived d;
	Base* pb = &d;
	Derived* pd = &d;

	pb->f(3.14f);
	pd->f(3.14f);

	cout << endl;
	pb->g(100);			//与Derived::g(int)参数完全吻合
	pd->g(100.86f);		//与Base::g(float)参数完全吻合

	cout << endl;
	pb->h(100.86f);
	pd->h(100.86f);

	return 0;
}

• 函数Derived::f(float) 覆盖了 Base::f(float)
• 函数Derived::g(int) 隐藏了 Base::g(float)，而不是重载
• 函数Derived::h(float) 隐藏了 Base::h(float)，而不是覆盖

摆脱隐藏

隐藏规则引起了不少麻烦。

• 示例3中，语句pd->f(10)的本意是想调用函数Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隐藏了。
• 由于数字10不能被隐式地转化为字符串，所以在编译时出错。

示例3：

#include <iostream>
using namespace std;

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

class Derived : public Base
{
public:
	void f(char *str) {}
};


int main()
{
	Derived *pd = new Derived;
	pd->f(10);	//error

	return 0;
}

从示例3 看来，隐藏规则似乎很愚蠢。

但是隐藏规则至少有两个存在的理由：

• 写语句pd->f(10)的人可能真的想调用Derived::f(int)，只是他误写错了，有了隐藏规则，编译器就可以明确的指出错误，未必是件坏事。
• 假如Derived有多个基类（多重继承），有时搞不清楚哪些基类定义了函数f。那么pd->f(10)可能会出乎意料地调用了基类函数f。尽管隐藏规则看起来不怎么有道理，但是能明确的消除这些意外