C++：重载、覆盖与隐藏

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

一.成员函数重载：

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

2.函数名字相同

3.参数相同（返回值，形参列表都相同）

4.virtual关键字可有可无

二.覆盖是指派生类函数覆盖基类函数

1.范围不同，一个基类，一个派生类

2.函数名字相同

3.参数相同

4.基类函数必须要有virtual关键字

以下代码，派生类Derived中成员函数g（）覆盖了基类的成员函数g（）

#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;}
};

三.迷惑的隐藏规则

基类函数与派生类函数的两种情况

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.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; }
};

四.隐藏规则导致的问题

隐藏规则似乎很愚蠢。但是隐藏规则至少有两个存在的理由：

看下代码

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。尽管隐藏规则看起来不怎么有道理，但它的确能消灭这些意外。

3. 如果语句pd->f(10)一定要调用函数Base::f(int)，那么将类Derived修改为如下即可。

   class Derived : public Base

   {

   public:

   void f(char *str);

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

   };