重载、覆盖与隐藏

 重载（overload）用于同一个类中的成员函数，其特征为：
（1）相同的范围（在同一个类中）；
（2）相同的函数名字；
（3）参数不同（包括参数类型不同，或参数个数不同，或两者都不同。注意：和返回值没关系）；
（4）和是否为虚函数无关。
覆盖（override）是指派生类函数覆盖基类函数，其特征为：
（1）不同的范围（分别位于派生类与基类）；
（2）相同的函数名字；
（3）参数相同（即参数类型和参数个数均相同）；
（4）基类函数必须是虚函数。
隐藏（hide）是指派生类的函数屏蔽了与其同名的基类函数，其特征为：
（1）不同的范围（分别位于派生类与基类）；
（2）相同的函数名字；
（3）若参数不同，基类函数无virtual关键字，基类函数将会被隐藏。（因为派生类和基类不在同一范围，所以是隐藏而不是重载）；
（4）若参数不同，基类函数有virtual关键字。基类函数将会被隐藏。（因为派生类和基类不在同一范围，所以是隐藏而不是重载；因为参数不同，所以是隐藏而不是覆盖）；
（5）若参数相同，基类函数无virtual关键字。基类函数将会被隐藏。（因为基类函数不是虚函数,所以是隐藏而不是覆盖）。
（6）若参数相同，基类函数有virtual关键字。如果基类函数有多个重载版本，且派生类并没有重写所有的同名虚函数,当在派生类中调用函数时，基类中未被重写的虚函数将被隐藏。（当然，被重写的函数就是覆盖了）。
注意: 如果想在派生类中调用基类中的被隐藏的函数，可以在派生类中填写如下代码：using Base::Fun2;

#include <iostream.h>

class Base
{
public:
    // overload between Fun1() and Fun1(int i)
    void Fun1()
    {
        cout<<"Base::Fun1()"<<endl;
    }

    void Fun1(int i)
    {
        cout<<"Base::Fun1(int i)"<<endl;
    }

    // overload between Fun2() and Fun2(int i)
    virtual void Fun2()
    {
        cout<<"Base::Fun2()"<<endl;
    }

    virtual void Fun2(int i)
    {
        cout<<"Base::Fun2(int i)"<<endl;
    }
};

class Derive : public Base
{
public:
// using Base::Fun2;

 // overload between Fun1(int i, int j) and Fun1(int i)   
 // hide-3
    void Fun1(int i, int j)
    {
        cout<<"Derive::Fun1(int i, int j)"<<endl;
    }

 // hide-5
 void Fun1(int i)
    {
        cout<<"Derive::Fun1(int i)"<<endl;
    }

 // overload between Fun2(int i, int j) and Fun2(int i)
 // hide-4
    virtual void Fun2(int i, int j)
    {
        cout<<"Derive::Fun2(int i, int j)"<<endl;
    }

 // override Base::Fun2(int i)
 // hide-6
    void Fun2(int i)
    {
        cout<<"Derive::Fun2(int i)"<<endl;
    } 
};

void main()
{
    Derive d;
    Base *pb = &d;
    Derive *pd = &d;

    pb->Fun1();     // Base::Fun1()
    pb->Fun1(1);    // Base::Fun1(int i)
    pb->Fun2();     // Base::Fun2()
    pb->Fun2(1);    // Derive::Fun2(int i)

    cout<<endl;
    pd->Fun1(1, 2); // Derive::Fun1(int i, int j)
    pd->Fun1(1);    // Derive::Fun1(int i)
    // error: no overloaded function takes 0 parameters
    // hide-3 or hide-5 can hide this base function
    // pd->Fun1();

    pd->Fun2(1, 2); // Derive::Fun2(int i, int j)
    pd->Fun2(1);    // Derive::Fun2(int i)
    // error: no overloaded function takes 0 parameters
    // hide-4 or hide-6 can hide this base function
    // pd->Fun2();
}

附：在C#中，编译器已经可以对隐藏发出2级警告。