结合以下 C++ 代码，深入理解重载（Overload）、隐藏（Hide） 和覆盖（Override，也叫重写） 这三个核心概念，用这段代码作为核心案例，由浅入深地拆解它们的区别和本质。
一、先明确三个概念的核心定义
这三个概念都是 C++ 中函数名复用的场景，但适用范围、规则和目的完全不同，先看一张对比表建立整体认知：
| 概念 | 中文名称 | 适用范围 | 核心特征 | 本质目的 |
|---|---|---|---|---|
| Overload | 重载 | 同一个作用域内 | 函数名相同，参数列表（个数/类型/顺序）不同，返回值不影响 | 方便同一功能的不同参数调用 |
| Override | 覆盖/重写 | 子类与父类之间 | 子类重写父类的虚函数，函数签名（名 + 参数+const）完全一致 | 实现多态（运行时动态绑定） |
| Hide | 隐藏/遮蔽 | 子类与父类之间 | 子类函数名覆盖父类同名函数（无论参数/虚函数与否），编译期静态屏蔽 | 作用域优先原则导致的'遮蔽' |
覆盖是特殊的隐藏。
二、结合代码逐个拆解
逐个分析这三个概念，并用扩展代码演示效果。
1. 重载（Overload）—— 同一作用域内的'同名不同参'
核心规则：
- 必须在同一个类/同一个作用域中；
- 函数名完全相同；
- 参数列表必须不同（个数、类型、顺序，三者至少一个不同）；
- 返回值、是否是虚函数不影响重载（但仅返回值不同不算重载）。
代码中的重载案例：
在 Base 类中，两个 show 函数就是典型的重载：
class Base {
public:
Base(int a) : ma(a) {}
// 重载 1：无参 show
virtual void show() {
cout << "Base::show()" << endl;
}
// 重载 2：带 int 参数的 show —— 与上面构成重载
virtual void show(int i) {
cout << "Base::show(int)" << endl;
}
private:
int ma;
};
- 它们在
Base这个同一作用域内； - 函数名都是
show； - 参数列表不同（一个无参，一个 int 参数）；
- 都是虚函数（但即使不是虚函数，依然是重载）。
重载的调用示例：
int main() {
Base b(10);
b.show(); // 调用 Base::show() —— 匹配无参版本
b.show(5); // 调用 Base::show(int) —— 匹配 int 参数版本
return 0;
}
编译期编译器会根据实参类型自动匹配对应的重载函数，这是静态绑定（编译期确定调用哪个）。
2. 覆盖/重写（Override）—— 子类对父类虚函数的'精准替换'
核心规则：
- 必须在子类与父类之间；
- 父类函数必须是虚函数（virtual）；
- 子类函数的函数签名完全一致（函数名 + 参数列表 + const/volatile 属性完全相同）；
- 子类函数可以加
override关键字显式声明（C++11 后推荐，编译器会检查是否真的覆盖）。
代码中的覆盖案例：
Derive 类中的 show() 覆盖了 Base 类中的无参 show()：
class Derive : public Base {
public:
Derive(int a, int b) : Base(a), mb(b) {}
// 覆盖：与 Base::show() 签名完全一致，且父类是虚函数
void show() override {
cout << "Derive::show()" << endl;
}
// 加 override 更规范
private:
int mb;
};
- 父类
Base::show()是虚函数； - 子类
Derive::show()函数名、参数列表（无参）完全一致； - 这就是'覆盖'，目的是实现多态。
覆盖的多态调用示例：
int main() {
Base* ptr = new Derive(1, 2); // 父类指针指向子类对象
ptr->show(); // 调用 Derive::show() —— 运行时动态绑定（多态）
delete ptr;
return 0;
}
输出：Derive::show()
这里因为覆盖了虚函数，运行时会根据对象的实际类型（Derive）调用对应的函数，而不是指针类型（Base），这是动态绑定。
3. 隐藏/遮蔽（Hide）—— 子类对父类同名函数的'编译期屏蔽'
核心规则：
- 必须在子类与父类之间；
- 子类定义了与父类同名的函数（无论参数是否相同、是否是虚函数）；
- 编译器在编译子类作用域时，会屏蔽父类所有同名函数，即使父类是重载/虚函数；
- 这是编译期静态行为，与多态无关。
代码中的隐藏案例（重点！）：
你的代码中，Derive 类定义了 show()，会隐藏父类 Base 中所有名为 show 的函数（包括 show() 和 show(int)）：
int main() {
Derive d(1, 2);
d.show(); // 正常：调用 Derive::show()
// d.show(5); // 编译错误！父类的 show(int) 被隐藏了
return 0;
}
为什么会报错？
因为子类 Derive 中有 show() 函数，编译器在解析 d.show(5) 时，会优先在 Derive 作用域找 show，发现只有无参的 show()，没有 show(int)，且不会去父类找（被隐藏了），因此编译失败。
隐藏的其他场景（补充理解）：
即使子类函数参数与父类不同，依然会隐藏：
class Derive : public Base {
public:
Derive(int a, int b) : Base(a), mb(b) {}
// 子类定义 show(double) —— 与父类 show(int) 不同参，但依然隐藏父类所有 show
void show(double d) {
cout << "Derive::show(double)" << endl;
}
private:
int mb;
};
int main() {
Derive d(1, 2);
// d.show(5); // 编译错误！父类 show(int) 被隐藏，子类只有 show(double)
d.show(5.0); // 正常：调用 Derive::show(double)
return 0;
}
如何解除隐藏？
如果想在子类中调用父类被隐藏的函数，有两种方式：
- 用
using声明，把父类函数引入子类作用域：
class Derive : public Base {
public:
using Base::show; // 解除父类所有 show 函数的隐藏
Derive(int a, int b) : Base(a), mb(b) {}
void show() override {
cout << "Derive::show()" << endl;
}
private:
int mb;
};
// 此时调用正常
int main() {
Derive d(1, 2);
d.show(); // 调用 Derive::show()
d.show(5); // 调用 Base::show(int) —— 隐藏被解除
return 0;
}
- 显式指定父类作用域调用：
int main() {
Derive d(1, 2);
d.Base::show(5); // 直接调用父类的 show(int)，不受隐藏影响
return 0;
}
三、容易混淆的点对比
1. 覆盖 vs 重载
| 维度 | 覆盖（Override） | 重载（Overload） |
|---|---|---|
| 作用域 | 跨类（父类→子类） | 同作用域（同一类） |
| 函数签名 | 必须完全一致 | 必须不同（参数列表） |
| 虚函数要求 | 父类必须是虚函数 | 无要求（可虚可非虚） |
| 绑定方式 | 运行时动态绑定 | 编译期静态绑定 |
2. 覆盖 vs 隐藏
| 维度 | 覆盖（Override） | 隐藏（Hide） |
|---|---|---|
| 前提 | 父类是虚函数 + 签名一致 | 只要子类有同名函数（无论参数/虚函数） |
| 本质 | 多态的实现方式 | 作用域优先导致的屏蔽 |
| 绑定方式 | 运行时动态绑定 | 编译期静态屏蔽 |
| 父类函数可用性 | 父类虚函数被'替换'但可通过作用域调用 | 父类同名函数被屏蔽，需显式调用 |
四、完整演示代码
把上述所有场景整合，可以直接运行测试：
#include <iostream>
using namespace std;
class Base {
public:
Base(int a) : ma(a) {}
// 重载 1：无参虚函数
virtual void show() {
cout << "Base::show()" << endl;
}
// 重载 2：带 int 参数的虚函数（与上面构成重载）
virtual void show(int i) {
cout << "Base::show(int) " << i << endl;
}
private:
int ma;
};
class Derive : public Base {
public:
using Base::show; // 解除父类 show 的隐藏（注释掉这行看隐藏效果）
Derive(int a, int b) : Base(a), mb(b) {}
// 覆盖：重写父类无参 show
void show() override {
cout << "Derive::show()" << endl;
}
// 新增：子类独有的 show(double)（会隐藏父类 show，除非加 using）
void show(double d) {
cout << "Derive::show(double) " << d << endl;
}
private:
int mb;
};
int main() {
// 1. 测试 Base 的重载
Base b(10);
b.show(); // Base::show()
b.show(5); // Base::show(int) 5
// 2. 测试多态（覆盖）
Base* ptr = new Derive(1, 2);
ptr->show(); // Derive::show() —— 动态绑定
ptr->show(6); // Base::show(int) 6 —— 子类未覆盖该版本，调用父类
delete ptr;
// 3. 测试子类的隐藏与解除
Derive d(1, 2);
d.show(); // Derive::show()
d.show(7); // Base::show(int) 7（加 using 后生效，否则编译错误）
d.show(3.14); // Derive::show(double) 3.14
d.Base::show(); // 显式调用父类 show()
return 0;
}
总结
- 重载是同一作用域内'同名不同参'，编译期静态匹配，目的是简化调用；
- 覆盖是子类重写父类虚函数（签名一致），运行时动态绑定，是多态的核心；
- 隐藏是子类同名函数屏蔽父类所有同名函数（编译期行为），需用
using或作用域显式调用父类函数。
这三个概念的核心区别在于作用域和绑定时机：重载是'同作用域 + 编译期'，覆盖是'跨类 + 运行期'，隐藏是'跨类 + 编译期屏蔽'。
补充
#include <iostream>
using namespace std;
class Base {
public:
Base(int a) : ma(a) {}
// 虚函数
virtual void show() {
cout << "Base::show()" << endl;
}
virtual void show(int i) {
cout << "Base::show(int)" << endl;
}
private:
int ma;
};
class Derive : public Base {
public:
Derive(int a, int b) : Base(a), mb(b) {}
void show() {
cout << "Derive::show" << endl;
}
private:
int mb;
};
补充说明
- 虚函数与重写：
Base类中定义了两个虚函数show()和show(int i)。Derive类重写了无参版本show()，但没有重写带参版本show(int i)。- 由于 C++ 的名称隐藏规则，
Derive类中定义的show()会隐藏掉基类中所有名为show的函数（包括show(int i)）。
典型调用行为：
int main() {
Derive d(1, 2);
d.show(); // 正确，调用 Derive::show()
// d.show(10); // 编译错误！基类的 show(int) 被隐藏了
return 0;
}
如果想在 Derive 中也能调用 Base::show(int)，需要在 Derive 中添加 using Base::show; 来解除名称隐藏。