c++ 重载 覆盖 隐藏特征分析

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

每个类维护一个自己的名字空间，即类域，所以派生类跟基类处于不同的空间之中，因些，虽然派生类自动继承了基类的成员变量及成员函数，但基类的函数跟派生类的函数不可能直接构成函数重载，因为它们处于两个不同的域。

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

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

隐藏规则的底层原因是Ｃ＋＋的名字解析过程，即name lookup问题，在继承机制下，派生类的名字解析过程如下：

   1.首先在派生类类域中查找该名字。

   2.若在派生类的类域中无法找到该名字，编译器则从基类中查找该名字

   3.若在基类类域中也找不到该名字，编译器则报错

所以，当基类跟派生类共享一个名字时，派生类成员是“隐藏了对基类成员的直接访问”！只要加上作用域限定，还是可以访问到基类成员的。

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

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

覆盖规则其实就是C++虚函数表的实现原理.当派生类和基类中的存在同名函数，且参数个数和参数类型完全相同，并且基类中的该函数有virtual修饰（派生类中的该函数可有可无），则派生类的该函数覆盖掉基类的该函数。该性质用来实现多态。

虚函数是指在一个类中，用virtual关键字声明的函数都是虚函数。

虚函数存在的唯一目的，就是为了实现多态（动态绑定/运行时绑定）。虚函数只有在基类和派生类之间才能发挥虚特性。在同一个类中，所有虚函数就和普通函数是一样，使用同样的重载规则。因此在同一个类中可以把虚函数看作普通函数来使用（因为其虚特性发挥不出来），使用方法和注意事项与普通函数一模一样

示例代码

<span style="font-size:18px;">class A
{
public:
    void f()//重载
    {
        std::cout << "A: f" << endl;
    }
    void f(int m, int n)//重载
    {
        std::cout << "A: f_int_int" << endl;
    }
    virtual void g()//虚函数
    {
        std::cout << "A:g" <<endl;
    }
    void h(int m)//int 类型
    {
        std::cout << "A: h_int" << endl;
    }
};
class B: public A
{
public:
    void f()//重载
    {
        std::cout << "B: f" << endl;
    }
    void f(int m, int n)//重载
    {
        std::cout << "B: f_int_int" << endl;
    }
    virtual void g()//虚函数,覆盖
    {
        std::cout << "B:g" <<endl;
    }
    void h(float m)//float 类型
    {
        std::cout << "B: h_float" << endl;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    A *pBaseA = new A;
    pBaseA->f();    //调用A::f()
    pBaseA->f(0,1); //调用A::f(int,int)
    pBaseA->g();    //调用A::g()

    pBaseA = new B;
    pBaseA->f();    //无virtual关键字，函数重载 调用A::f()
    pBaseA->f(3,4); //无virtual关键字，函数重载 调用A::f(int,int)
    pBaseA->g();    //有virtual关键字，发生多态，子类覆盖基类 调用B::g()

    B *pDerive = new B;          
    pDerive->f();     //函数重载 调用B::f()
    pDerive->f(5,6);  //函数重载 调用B::f(int,int)
    pDerive->h(5);    //发生隐藏，在类域B中找到函数名h,参数隐式转换，调用B::h(float)
    pDerive->g();     //调用B::g
    return 0;
}</span>

参考博文：

http://www.cnblogs.com/fangshenghui/archive/2012/06/04/2534596.html
http://www.cnblogs.com/liangning/p/3968151.html