C++ 重写、重载、隐藏

原创于 2025-12-03 10:35:00 发布 · 658 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

C++知识点整理专栏收录该内容

4 篇文章

订阅专栏

在 C++ 中，重写（Override）、重载（Overload） 和 隐藏（Hide） 是三个容易混淆但非常重要的概念，它们都涉及函数名称相同的情况，但在语义、作用域和行为上有显著区别。下面将详细讲解三者的定义、规则、使用场景以及示例。

一、函数重载（Function Overloading）

定义

在同一作用域内（通常是同一个类或命名空间中），多个函数具有相同的名称但参数列表不同（参数类型、数量或顺序不同），称为函数重载。

特点

必须在同一作用域。
函数名相同，参数列表不同（返回值类型不能作为重载依据）。
编译器根据调用时的实参类型自动选择最匹配的函数（静态绑定，编译期决定）。
与 virtual 无关。

示例

#include <iostream>
using namespace std;

class Math {
public:
    int add(int a, int b) {
        return a + b;
    }
    double add(double a, double b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }
};

int main() {
    Math m;
    cout << m.add(1, 2) << endl;       // 调用 int add(int, int)
    cout << m.add(1.5, 2.5) << endl;   // 调用 double add(double, double)
    cout << m.add(1, 2, 3) << endl;    // 调用 int add(int, int, int)
}

⚠️ 注意：仅靠返回值不同无法构成重载，编译会报错。

二、函数重写（Override / 覆盖）

定义

在派生类中重新定义基类中的虚函数（即具有相同签名的 virtual 函数），称为重写（覆盖）。这是实现多态的关键机制。

条件（C++11 后建议使用 `override` 关键字）

基类函数必须是 virtual（或纯虚函数）。
派生类函数与基类函数函数名、参数列表、const 限定符完全一致。
返回类型需满足协变规则（通常相同，或为指向派生类/基类的指针或引用）。
访问权限可以不同（但不推荐改变）。

特点

发生在继承关系中。
实现运行时多态（动态绑定）。
通过基类指针或引用调用时，实际执行的是派生类版本。

示例

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base::show()" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {  // C++11 推荐加 override
        cout << "Derived::show()" << endl;
    }
};

int main() {
    Base* p = new Derived();
    p->show();  // 输出: Derived::show()
    delete p;
}

✅ 使用 override 关键字可让编译器检查是否真的重写了基类虚函数，避免拼写错误等 bug。

三、函数隐藏（Name Hiding）

定义

在派生类中定义了一个与基类同名的函数（无论参数是否相同），如果没有使用 virtual 且不满足重写条件，则基类的同名函数会被隐藏（即使参数不同）。

规则（C++ 名称查找规则）

在派生类中声明了与基类同名的函数 → 基类所有同名函数（包括重载版本）都被隐藏。
即使参数不同，也无法通过派生类对象直接调用基类版本（除非显式使用 using 声明）。
隐藏与 virtual 无关；只要不是重写，就可能隐藏。

示例 1：参数不同 → 隐藏

#include <iostream>
using namespace std;

class Base {
public:
    void func(int x) { cout << "Base::func(int)" << endl; }
    void func(double x) { cout << "Base::func(double)" << endl; }
};

class Derived : public Base {
public:
    void func(char c) { cout << "Derived::func(char)" << endl; }
};

int main() {
    Derived d;
    d.func('a');     // OK: Derived::func(char)
    // d.func(10);   // ❌ 错误！Base::func(int) 被隐藏了！
    // d.func(1.5);  // ❌ 错误！Base::func(double) 也被隐藏！
}

解决方法：使用 `using`

class Derived : public Base {
public:
    using Base::func;  // 引入基类所有 func 重载版本
    void func(char c) { cout << "Derived::func(char)" << endl; }
};
// 现在 d.func(10) 可以调用 Base::func(int)

示例 2：有 `virtual` 但签名不同 → 也隐藏

class Base {
public:
    virtual void foo(int x) { cout << "Base::foo(int)" << endl; }
};

class Derived : public Base {
public:
    void foo(double x) { cout << "Derived::foo(double)" << endl; } // 不是重写！是隐藏！
};

对比总结

特性	重载（Overload）	重写（Override）	隐藏（Hide）
作用域	同一作用域（如同一个类）	不同作用域（基类 vs 派生类）	不同作用域（基类 vs 派生类）
函数名	相同	相同	相同
参数列表	必须不同	必须相同	可同可不同
virtual	无关	基类函数必须是 `virtual`	无关（即使有 virtual 但签名不同也会隐藏）
绑定时机	编译期（静态）	运行期（动态）	编译期（静态）
是否多态	否	是	否
如何避免隐藏	—	—	使用 `using Base::func;`