一文彻底解决C++中的重载、重写和隐藏操作
往期C++系列相关内容：
C++ 类中静态成员和静态成员函数的继承覆盖
C++中的.和-＞
网络相关内容：
select、poll、epoll、多线程实现并发请求处理
epoll的水平触发LT以及边沿触发ET的原理及使用及优缺点
一文彻底解决C++中的重载、重写和隐藏操作，本文基本将所有的重载、重写、隐藏出现的情况罗列了出来，如果有纰漏或者错误还请指正。
直接上菜！！！！！！！！！！！！！（此处看不懂请直接跳到”重载“内容。）
假设两个函数在同个一类中，函数名相同，则可能会有这些情况产生。
表中，返回值相同的意思是，两个同名函数的返回值的类型相同；虚函数（Y）的意思是假设被重载的函数是虚函数，虚函数（N）表示不是虚函数；输入参数（Y）表示输入参数的形式相同（参数个数，参数类型都相同），输入参数（N）表示输入参数的类型不同。
| 返回值相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 编译出错 |
| 输入参数（N） | 重载 | 重载 |
表中，返回值不相同的意思是，两个同名函数的返回值的类型不相同；
| 返回值不相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 编译出错 |
| 输入参数（N） | 重载 | 重载 |
假设两个函数在不同类中，函数名相同，则可能会有这些情况产生。
表中，返回值相同的意思是，两个同名函数的返回值的类型相同；虚函数（Y）的意思是假设被基类的函数是虚函数，虚函数（N）表示不是虚函数；输入参数（Y）表示输入参数的形式相同（参数个数，参数类型都相同），输入参数（N）表示输入参数的类型不同。
| 返回值相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 重写 | 隐藏 |
| 输入参数（N） | 隐藏 | 隐藏 |
| 返回值不相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 隐藏 |
| 输入参数（N） | 隐藏 | 隐藏 |
重载（overload）
重载是指在同一范围定义中的同名成员函数才存在重载关系。
同一范围：例如重载关系的两个函数都是全局函数或者都在一个类中。
这个“同一范围”的限制条件很重要！！！！！！！！ 假如在不同类中/父子类中的函数都不存在重载情况
特点：函数名相同，参数类型和数目有所不同。
举个例子：
#include <iostream>
using namespace std;
class Solutuion {
public:
void Max(int a, int b)//输入参数都是int类型
{
cout << "Max 1" << endl;
}
void Max(char a, int b)//与上面的函数函数名相同，但第一个输入参数是char类型。发生重载
{
cout << "Max 2" << endl;
}
};
int main() {
Solutuion test;
test.Max(1,2);
test.Max('a',2);
return 0;
}
结果：
重载中的注意事项
易错注意点：
注意1：参数个数和类型均相同，返回值不同的相同函数名的函数是错误的，不能重载。（编译错误）
例如：
class Solutuion {
public:
void Max(int a, int b)
{
cout << "Max 1" << endl;
}
int Max(int a, int b) //和上面的函数名以及输入参数都相同。仅仅返回类型不同。发生编译错误，无法编译通过
{
cout << "Max 2" << endl;
return 0;
}
};
注意2：重载功能与函数成员是否是虚函数无关。
class Solutuion {
public:
virtual void Max(int a, int b)
{
cout << "Max 1" << endl;
}
void Max(char a, int b)//虽然上面是虚函数，但这也是重载
{
cout << "Max 2" << endl;
}
};
其实可以理解成虚函数（virtual）只在不同范围内（如父类和子类）起作用。在上述程序中，函数都处于一个类，判断两个函数的关系可以不用看是否是虚函数。
比如下面这种错误的例子：
class Solutuion {
public:
virtual void Max(int a, int b)//虚函数
{
cout << "Max 1" << endl;
}
void Max(int a, int b)//不是虚函数，但函数名，输入参数都一样。编译错误：重复声明类成员函数
{
cout << "Max 2" << endl;
}
};
重写（override）
重写指的是在派生类中覆盖基类中的同名函数，重写就是重写函数体。
特点：
-
要求基类函数必须是虚函数
-
与基类的虚函数有相同的参数个数
-
与基类的虚函数有相同的参数类型
-
与基类的虚函数有相同的返回值类型
举个例子：
#include <iostream>
using namespace std;
class A {
public:
virtual void Max(int a, int b)//输入参数都是int类型
{
cout << "Max 1" << endl;
}
};
class B : public A{//B继承了A类
public:
void Max(int a, int b)//输入参数都是int类型， 父类是虚函数，发生了重写
{
cout << "Max 2" << endl;
}
};
int main() {
A Atest;
Atest.Max(1,2);
B Btest;
Btest.Max(1,2);
return 0;
}
结果：
重写与重载的区别：
重写是父类和子类之间的垂直关系（不同类），重载是不同函数之间的水平关系（同一范围）
重写要求参数列表相同，返回值相同；重载则要求参数列表不同，返回值不要求（可相同可不同）
重写关系中，调用方法根据对象类型决定；重载根据调用时实参表与形参表的对应关系来选择函数体
重写中的注意事项
注意一点：返回值必须相同。（有个协变的概念，返回的类型“小于”父类也可以，这种情况本文不研究）
例如下面错误的例子：
class A {
public:
virtual void Max(int a, int b)//输入参数都是int类型
{
cout << "Max 1" << endl;
}
};
class B : public A{//B继承了A类
public:
int Max(int a, int b)//输入参数都是int类型， 父类是虚函数，但是返回类型与父类不同，编译出错
{
cout << "Max 2" << endl;
return 0;
}
};
隐藏（hide）
函数的隐藏有两种形式：
隐藏1：位于父类与子类中的同名函数，返回值可以不同。两个函数参数相同，但是基类函数不是虚函数。
这个隐藏形式和重写的区别在于基类（父类）函数是否是虚函数。
举个例子：
#include <iostream>
using namespace std;
class A {
public:
void Max(int a, int b)//输入参数都是int类型
{
cout << "Max 1" << endl;
}
};
class B : public A{//B继承了A类
public:
void Max(int a, int b)//输入参数都是int类型， 父类不是虚函数。隐藏父类的Max函数
{
cout << "Max 2" << endl;
}
};
int main() {
A Atest;
Atest.Max(1,2);
B Btest;
Btest.Max(1,2);
return 0;
}
结果：
隐藏2：位于父类与子类中的同名函数，返回值可以不同。如果参数列表不同，无论基类函数是不是虚函数。子类中的函数都会隐藏父类的同名函数。
这个隐藏形式和重载的区别在于两个函数不在同一个类中。
举个例子：
#include <iostream>
using namespace std;
class A {
public:
void Max(int a, int b)//输入参数都是int类型
{
cout << "Max 1" << endl;
}
};
class B : public A{//B继承了A类
public:
void Max(char a, int b)//输入参数类型不同。会隐藏父类的Max函数
{
cout << "Max 2" << endl;
}
};
int main() {
A Atest;
Atest.Max(1,2);
B Btest;
Btest.Max(1,2);
return 0;
}
结果：
隐藏中的注意事项
注意：假如基类的函数被隐藏掉，指向子类的对象是无法调用被隐藏的函数。编译时就会出错。
例如：
#include <iostream>
using namespace std;
class A {
public:
void Max(int a, int b){}
};
class B : public A{
public:
int Max(char a){
return 0;
}
};
int main() {
A Atest;
Atest.Max(1,2);
B Btest;
Btest.Max('a');//正确调用
Btest.Max(1,2);//编译出错，虽然基类中的函数符合它的传入参数形式，但是基类中符合它类型的函数已经被隐藏了
return 0;
}
总结
到此为止对于重载、重写、隐藏的解释基本完成了，但还有一些情况没说明到。下面从排列组合所有会发生的情况总结一下。
上面的示例主要涉及到这几个不定项：
返回值类型是否相同，父类中的同名函数是否虚函数，输入参数是否相同。
由于重载只能在同一范围内，而重写和隐藏在不同的类中，因此将重载独立出来分析。采用函数在同一个类中来总结所有情况
同一个类中
（同一个类就不涉及父类虚函数的情况了，指的是被重载的函数是虚函数的情况）
//返回值类型相同的情况
// 返回值类型相同 是虚函数 输入参数不同
virtual void Max(int a, int b) {}
void Max(char a, int b){} //重载
// 返回值类型相同 不是虚函数 输入参数不同
void Max(int a, int b) {}
void Max(char a, int b){} //重载
// 返回值类型相同 是虚函数 输入参数相同
virtual void Max(int a, int b) {}
void Max(int a, int b){} //编译错误，重声明
// 返回值类型相同 不是虚函数 输入参数相同
void Max(int a, int b) {}
void Max(int a, int b){} //编译错误，重声明
//返回值类型不相同的情况
// 返回值类型不相同 是虚函数 输入参数不同
virtual void Max(int a, int b) {}
int Max(char a, int b){} //重载
// 返回值类型不相同 不是虚函数 输入参数不同
void Max(int a, int b) {}
int Max(char a, int b){} //重载
// 返回值类型不相同 不是虚函数 输入参数相同
void Max(int a, int b) {}
int Max(int a, int b){} //编译错误
// 返回值类型不相同 是虚函数 输入参数相同
virtual void Max(int a, int b) {}
int Max(int a, int b){} //编译错误
首尾呼应，表格展示
| 返回值相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 编译出错 |
| 输入参数（N） | 重载 | 重载 |
| 返回值不相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 编译出错 |
| 输入参数（N） | 重载 | 重载 |
不同类中
不同类中会发生重写或隐藏的情况，不会发生重载
//返回值类型相同的情况
// 返回值类型相同 是虚函数 输入参数不同
class A {public: virtual void Max(int a, int b){}};//为了节省空间，就没按照编程规范写了，勿怪
class B : public A{public: void Max(char a, int b){}};//隐藏
// 返回值类型相同 不是虚函数 输入参数不同
class A {public: void Max(int a, int b){}};
class B : public A{public: void Max(char a, int b){}};//隐藏
// 返回值类型相同 是虚函数 输入参数相同
class A {public: virtual void Max(int a, int b){}};
class B : public A{public: void Max(int a, int b){}};//重写
// 返回值类型相同 不是虚函数 输入参数相同
class A {public: void Max(int a, int b){}};
class B : public A{public: void Max(int a, int b){}};//隐藏
//返回值类型不相同的情况
// 返回值类型不相同 是虚函数 输入参数不同
class A {public: virtual void Max(int a, int b){}};//
class B : public A{public: int Max(char a, int b){return 0;}};//隐藏
// 返回值类型不相同 不是虚函数 输入参数不同
class A {public: void Max(int a, int b){}};
class B : public A{public: int Max(char a, int b){return 0;}};//隐藏
// 返回值类型不相同 是虚函数 输入参数相同
class A {public: virtual void Max(int a, int b){}};
class B : public A{public: int Max(int a, int b){return 0;}};//编译出错
// 返回值类型不相同 不是虚函数 输入参数相同
class A {public: void Max(int a, int b){}};
class B : public A{public: int Max(int a, int b){return 0;}};//隐藏
| 返回值相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 重写 | 隐藏 |
| 输入参数（N） | 隐藏 | 隐藏 |
| 返回值不相同 | 虚函数（Y） | 虚函数（N） |
|---|---|---|
| 输入参数（Y） | 编译出错 | 隐藏 |
| 输入参数（N） | 隐藏 | 隐藏 |
希望本文可以让你系统的了解重载、重写和隐藏的特点和各自的区别。如果有错误内容，还请指出。
希望每一次发奋努力的背后，必有加倍的赏赐赋予。
