C++ 函数：重载、覆盖、隐藏

在 C++ 面向对象编程中，函数重载（Function Overload）、函数覆盖（Function Override）以及函数隐藏（Function Hide）这三个核心概念虽然都涉及函数的使用，但它们各自具有截然不同的语义和应用场景，常常让初学者感到困惑。这些概念本质上描述了函数在不同继承关系和作用域条件下的行为规则，理解它们的区别对于编写正确且高效的面向对象代码至关重要。

函数重载（Overload）指的是在同一个作用域内（通常是同一个类或命名空间），可以定义多个同名函数，但这些函数的参数列表必须有所不同（包括参数的类型、数量或顺序）。编译器会根据调用时提供的实参来决定具体调用哪一个重载版本的函数。需要注意的是，函数重载与函数的返回类型无关，仅通过返回类型的不同是无法实现重载的。重载主要发生在同一个类内部或者全局作用域中，它允许程序员以统一的函数名来执行相似但参数不同的操作，从而提高代码的可读性和灵活性。

函数重载的定义需同时具备以下几点：

1. 同一作用域：通常是同一类或同一命名空间内。

2. 函数名相同，参数列表不同：参数类型、个数、顺序至少有一个不同。

3. 与返回值类型无关：仅靠返回值不同无法构成重载。

4. 编译期多态：编译器在编译时根据参数匹配确定调用的是哪个函数。

参考代码如下：

#include <iostream>
using namespace std;
// 重载函数：同一作用域，函数名相同，参数不同int Add(int a, int b){    cout << "call Add(int,int): ";    return a + b;}
// 参数类型不同double Add(double a, double b){    cout << "call Add(double, double): ";    return a + b;}
// 参数个数不同int Add(int a, int b, int c){    cout << "call Add(int, int): ";    return a + b + c;}
int main(){    cout << Add(1, 2) << endl;     // 调用 int Add(int, int)    cout << Add(1.5, 2.5) << endl; // 调用 double Add(double, double)    cout << Add(1, 2, 3) << endl;  // 调用 int Add(int, int, int)    return 0;}
// 输出：call Add(int,int): 3call Add(double, double): 4call Add(int, int): 6

复制代码

函数覆盖（Override）特指在类的继承体系中，派生类重新定义基类中的虚函数（virtual function）的行为。为了实现覆盖，基类中的函数必须被声明为虚函数，而派生类中的同名函数需要与基类中的虚函数具有完全相同的函数签名（即函数名、参数列表和返回类型都必须一致）。当通过基类指针或引用调用该虚函数时，实际执行的是派生类中覆盖后的版本，这就是所谓的运行时多态（Runtime Polymorphism）。覆盖机制使得派生类可以根据自身的需求定制或扩展基类的行为，是实现面向对象设计中多态性的关键手段。

函数覆盖的定义需同时具备以下几点：

1. 继承关系：必须发生在基类与派生类之间。

2. 基类函数必须是虚函数：用 virtual 声明。

3. 函数原型完全相同：函数名、参数列表、返回值类型必须一致（C++11 允许协变返回类型，即派生类返回值可以是基类返回值的派生类型）。

4. 访问权限：派生类覆盖的函数访问权限可以不同（但通常建议保持一致）。

5. 运行期多态：通过基类指针或引用调用时，实际调用的是派生类的覆盖函数（取决于对象的实际类型）。

参考代码如下：

#include <iostream>using namespace std;
class Base{public:    Base()          = default;    virtual ~Base() = default;
public:    // 基类虚函数    virtual void Show()    {        cout << "Base::show()" << endl;    }};
class Derived : public Base{public:    // 覆盖基类虚函数（C++11 用 override 显式声明，更安全）    void Show() override    {        cout << "Derived::Show()" << endl;    }};
int main(){    Base* ptr = new Derived(); // 基类指针指向派生类对象    ptr->Show();               // 运行期多态：调用 Derived::Show()（覆盖生效）    delete ptr;    return 0;}
// 输出：Derived::Show()

复制代码

函数隐藏（Hide）是指当派生类中定义了一个与基类中同名函数（无论是否为虚函数）时，如果派生类的函数签名与基类函数不完全相同（即没有形成有效的覆盖），那么派生类的函数会将基类中的同名函数隐藏起来。这意味着，即使在派生类对象中调用该函数名，如果没有通过显式的作用域解析运算符（::）指定基类，编译器也不会考虑基类中的同名函数版本。函数隐藏不仅可能发生在普通成员函数之间，也可能发生在虚函数未被正确覆盖的情况下，因此理解隐藏机制有助于避免在继承体系中意外地屏蔽基类的功能。

函数隐藏的定义需同时具备以下几点：

1. 继承关系：发生在基类与派生类之间。

2. 函数名相同，但不满足覆盖条件：

a. 基类函数不是虚函数。

b. 参数列表不同（即使基类是虚函数，参数不同也会隐藏而非覆盖）。

3. 派生类中无法直接访问基类被隐藏的函数：需显式通过 “基类名::函数名” 调用。

4. 编译期确定：通过派生类对象或指针调用时，优先匹配派生类的函数，基类同名函数被隐藏。

参考代码如下：

#include <iostream>using namespace std;
class Base{public:    Base()          = default;    virtual ~Base() = default;
public:    // 基类非虚函数    void Hide(int x)    {        cout << "Base::Hide(int): " << x << endl;    }
    // 基类是虚函数    virtual void VirHide(int x)    {        cout << "Base::VirHide(int): " << x << endl;    }};
class Derived : public Base{public:    // 函数名相同，参数不同 → 隐藏基类的 Hide(int)    void Hide(double x)    {        cout << "Derived::Hide(double): " << x << endl;    }
    // 基类是虚函数，但参数不同，仍会隐藏而非覆盖.    void VirHide(double x)    {        cout << "Derived::VirHide(double): " << x << endl;    }};
int main(){    Derived d;    d.Hide(10);          // 调用 Derived::Hide(double)（10 隐式转换为 double）    d.Hide(10.5);        // 调用 Derived::Hide(double)    d.VirHide(10);       // 调用 Derived::VirHide(double)（10 隐式转换为 double）    d.VirHide(10.5);     // 调用 Derived::VirHide(double)    d.Base::Hide(10);    // 显式调用基类被隐藏的函数    d.Base::VirHide(10); // 显式调用基类被隐藏的函数    return 0;}
// 输出：Derived::Hide(double): 10Derived::Hide(double): 10.5Derived::VirHide(double): 10Derived::VirHide(double): 10.5Base::Hide(int): 10Base::VirHide(int): 10