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
