0. 重载、隐藏、覆盖的区别

C++对于两个同名的函数有三种处理方式：重载（overload）、隐藏（hide）、覆盖（override）
用最简单的话概括：

重载	参数不同的同名函数
隐藏	子类的函数名与基类相同就会隐藏
覆盖	只用于虚函数

他们的区别如下：

同名函数	作用域	形参列表
重载	相同	不同
隐藏	不同	不同 / 相同且基类中同名函数不是虚函数
覆盖	不同	相同且基类中同名函数是虚函数

或者这样表示：

1. 重载

• 同名函数在同一个类中（作用域相同），但他们的参数个数 / 参数种类不同（形参列表不同），此时他们是重载关系，比如：

class DAD
{
    public:
        void show(){
            cout << "I am dad" << endl;
        }
        void show(int x){
            cout << x << endl;
        }
};

对于重载函数，想调用哪个函数，取决于你给的参数
比如你想输出一句话，那么直接调用show()函数即可；
而如果你想输出一个数字，则要给show()函数一个对应的实参，如show(3)；
他们对应的输出结果如下：

I am dad                //直接调用show();
3                       //给了参数的show(3);

2. 隐藏

• 如果同名函数在不同的类中，则他们不再是重载函数，
  若他们的形参列表不同，则基类中的同名函数将被隐藏（屏蔽），比如例A

//例 A
class DAD
{
    public:
        void show(){
            cout << "I am dad" << endl;
        }
};
class SON : public DAD
{
    public:
        void show(int x){
            cout << x << endl;
        }
}
int main(){
    SON a;
    a.show();
}

这时编译器会报错

[Error] no matching function for call to 'SON::show()'  

因为此时基类中的show()和子类中的函数同名而参数不同，满足隐藏的条件，子类从基类继承而来的没有参数的show()已经被隐藏，无法调用；
如果你要调用从基类中继承而来的show()，则要使用 作用域分辨符 “ :: ”,
它由两个冒号组成

a.DAD::show();

这时程序便会正确调用从基类继承而来的show()函数，输出如下：

I am dad

• 另一种情况是，同名函数在不同的类中、参数相同，且基类中的同名函数前没有virtual关键字声明，那么基类中的同名函数依然会被隐藏，比如例B：

//例 B
class DAD
{
    public:
        /* virtual */void show(){
            cout << "I am dad" << endl;
        }
};
class SON : public DAD
{
    public:
        void show(){
            cout << "I am son" << endl;
        }
}
int main(){
    SON a;
    a.show();
}

输出结果

I am son

P.S. 你可能会想，既然是对象a是子类，那a.show()不是理所当然地调用子类中的show()吗？
不妨再看看例C，

//例 C
class DAD
{
    public:
        void show(){
            cout << "I am dad" << endl;
        }
};
class SON : public DAD
{
    public:
        //子类没有show()函数了
}
int main(){
    SON a;
    a.show();
}

输出结果

I am dad

同样是a.show()，但这里调用的是从基类继承而来的show()；
所以a.show()并不是调用子类a中的show()，而是先看有没有从基类中继承而来的show()，然后再看子类中有没有同名的函数，如果子类已经有了同名函数，那么从基类继承而来的show()就会被隐藏，想调用就得用 “ :: ” 了

3. 覆盖

• 如果同名函数在不同的类中、参数相同且基类中的同名函数带有virtual关键字声明，
  那么这时基类中的同名函数将被覆盖（重写），它有两个特点：
  （1）当对象调用子类中的同名函数时，表现和被隐藏时相同，
  比如在例A、例B、例C中的基类同名函数前加上virtual关键字，程序结果不变（但其实和隐藏是不同的）；
  （2）当通过指针或引用调用子类中的同名函数时，由于需要区别指针（引用）的类型和指针（引用）所指对象的类型，此时的表现就和隐藏不同了——通过基类指针指向不同对象，指针会根据对象的类型不同，调用其相应的函数，比如下面的两个例子：

第一个例子，没有用虚函数，由于静态绑定，
通过“指向基类对象的基类指针”调用成员函数，调用的是基类的成员函数
通过“指向子类对象的基类指针”调用成员函数，调用的依然是基类的成员函数

class DAD
{
    public:
        /* virtual */ void show(){
            cout << "I am dad" << endl;
        }
};
class SON : public DAD
{
    public:
        void show(){
            cout << "I am son" << endl;
        }
};
//形参为指向基类对象的指针，用于接收来自对象的地址
void fun(DAD *p)
{
    p->show();
}
int main()
{
    DAD a; 
    SON b;
    fun(&a);    //用a对象的指针调用show()函数
    fun(&b);    //用b对象的指针调用show()函数
}

输出结果：

I am dad
I am dad

第二个例子，使用了虚函数，由于动态绑定，
通过“指向基类的基类指针”调用成员函数，调用的是基类中的虚函数
通过“指向子类的基类指针”调用成员函数，调用的则是子类中的实现（覆盖了基类中的虚函数）

class DAD
{
    public:
        virtual void show(){
            cout << "I am dad" << endl;
        }
};
class SON : public DAD
{
    public:
        void show(){
            cout << "I am son" << endl;
        }
};
//形参为指向基类对象的指针，用于接收来自对象的地址
void fun(DAD *p)
{
    p->show();
}
int main()
{
    DAD a; 
    SON b;
    fun(&a);    //用a对象的指针调用show()函数
    fun(&b);    //用b对象的指针调用show()函数
}

输出结果：

I am dad
I am son