C 语言

关注公众号 jb51net

关闭
首页 > 软件编程 > C 语言 > C++ 重载、隐藏、覆盖

C++ 重载、隐藏、覆盖的区别小结

作者：越甲八千

本文通过C++代码示例深入解析了重载(Overload)、覆盖(Override)和隐藏(Hide)三个核心概念的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

结合这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;
};

重载的调用示例：

int main() {
    Base b(10);
    b.show();    // 调用 Base::show() —— 匹配无参版本
    b.show(5);   // 调用 Base::show(int) —— 匹配int参数版本
    return 0;
}

编译期编译器会根据实参类型自动匹配对应的重载函数，这是静态绑定（编译期确定调用哪个）。

2. 覆盖/重写（Override）—— 子类对父类虚函数的“精准替换”

核心规则：

代码中的覆盖案例：

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;
};

覆盖的多态调用示例：

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;
}

如何解除隐藏？

如果想在子类中调用父类被隐藏的函数，有两种方式：

  1. 用 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;
}
  1. 显式指定父类作用域调用：
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;
}

总结

  1. 重载是同一作用域内“同名不同参”，编译期静态匹配，目的是简化调用；
  2. 覆盖是子类重写父类虚函数（签名一致），运行时动态绑定，是多态的核心；
  3. 隐藏是子类同名函数屏蔽父类所有同名函数（编译期行为），需用 using 或作用域显式调用父类函数。

这三个概念的核心区别在于作用域和绑定时机：重载是“同作用域+编译期”，覆盖是“跨类+运行期”，隐藏是“跨类+编译期屏蔽”。

补充

#include <iostream>
using namespace std;

class Base  // Base base(10);
{
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;
};

补充说明

  1. 虚函数与重写：

    • Base 类中定义了两个虚函数 show() 和 show(int i)。
    • Derive 类重写了无参版本 show()，但没有重写带参版本 show(int i)。
    • 由于 C++ 的名称隐藏规则，Derive 类中定义的 show() 会隐藏掉基类中所有名为 show 的函数（包括 show(int i)）。

  2. 典型调用行为：

    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; 来解除名称隐藏。

到此这篇关于C++ 重载、隐藏、覆盖的区别小结的文章就介绍到这了,更多相关C++ 重载、隐藏、覆盖内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文