C++ 名称隐藏的陷阱：为什么你的派生类函数调用失败？-CSDN博客

本文链接：https://blog.csdn.net/Long_xu/article/details/146023796

C++ 名称隐藏的陷阱：为什么你的派生类函数调用失败？

一、绪论
二、为什么会报错啊？
三、名称查找规则
四、如何避免名称隐藏问题？
五、总结

一、绪论

面向对象编程（OOP）作为一种卓越的设计范式，深刻地影响着现代软件的架构与开发。其中，继承（Inheritance）机制无疑是 OOP 王冠上的一颗璀璨明珠。继承是一种强大的特性，允许创建基于现有类的新的类，从而实现代码的复用、扩展和多态性。

C++，作为一门支持多种编程范式的强大语言，对继承提供了完善的支持。但是，如同所有强大的工具一样，继承也并非毫无挑战。在 C++ 的继承体系中，一个经常被忽视却又至关重要的概念是名称隐藏（Name Hiding），也被称为名称遮蔽。

名称隐藏是指 在派生类中声明一个与基类函数同名的成员（变量或函数），即使它们的签名（参数列表）不同，也会导致基类中所有同名成员在派生类中变得不可直接访问。这种机制的初衷是为了实现更精细的控制和特化，但如果理解不透彻，极易导致程序行为不符合预期，产生难以调试的错误。

本文以一个具体的示例为切入点，深入剖析 C++ 名称隐藏的概念、产生的原因和带来的影响。阐明 C++ 的名称查找规则，并探讨如何有效地避免和解决名称隐藏所带来的问题。本文旨在更深刻地理解 C++ 继承机制的内在运作方式。

二、为什么会报错啊？

有这样的 C++ 代码：

#include <string>
#include <iostream>
using namespace std;

template<class T>
class TestA {
public:
    TestA(string name) {
        this->name = name;
    }
    string getName() const{
        return name;
    }
    string getName(int x) const {
        return name + std::to_string(x);
    }
protected:
    string name;
};

template<class T>
class TestB : public TestA<T> {
public:
    TestB(string name) : TestA<T>(name) {}
protected:
    string getName(int x, int y) const {
        return name + "B";
    }
};
int main(int argc, char** argv) {
    TestA<int> a("test");
    cout << a.getName() << endl;
    cout << a.getName(1) << endl;

    TestB<int> b("testB");
    cout << b.getName(1) << endl;
    
    return 0;
}

期望 b.getName(1) 调用 TestA 类中的 getName(int x) 函数。编译看看：

test.cc: In function ‘int main(int, char**)’:
test.cc:36:14: error: no matching function for call to ‘TestB::getName(int)’
   36 |     b.getName(1);
      |     ~~~~~~~~~^~~
test.cc:26:12: note: candidate: ‘std::string TestB::getName(int, int) const’
   26 |     string getName(int x, int y) const {
      |            ^~~~~~~
test.cc:26:12: note:   candidate expects 2 arguments, 1 provided

什么？这段代码会产生一个编译错误。提示 TestB 类中没有名为 getName 且接受 int 类型参数的函数。

问题：为什么派生类对象 b 无法调用基类的 getName(int) 函数？

按理说，TestB 继承了 TestA，应该拥有 TestA 的所有成员函数，包括 getName(int)。

原因在于 TestB 类定义了一个名为 getName 的函数 getName(int x, int y)，它隐藏了 TestA 类中的所有同名函数（即使参数列表不同）。

注意，隐藏与函数重载（Overloading）是不同的。函数重载是指在同一个作用域内定义多个同名但参数列表不同的函数。隐藏发生在不同的作用域（基类和派生类），并且即使参数列表不同也会发生。

当基类函数为虚函数时，派生类可以使用 override 关键字显式地覆盖基类函数，这是一种更安全、更明确的方式。

在编写 C++ 代码时，很容易忽略这种细节，导致程序出现难以理解的错误。尤其是在大型项目中，类层次结构复杂，名称冲突的可能性更高，问题排查难度也会随之增加。

三、名称查找规则

在 C++ 中，当编译器遇到一个名称（变量名、函数名、类型名等）时，它需要确定该名称引用的是哪个实体。这个过程称为名称查找（Name Lookup）。 C++ 使用一套复杂的规则来查找名称，这些规则决定了编译器在哪个作用域中查找名称，以及查找的顺序。

继承中的名称查找关键在于查找顺序，直接关系到是否会发生名称隐藏。

当编译器遇到一个函数调用时，它会按照以下规则查找应该调用的函数：

从调用对象的类型开始查找： 编译器首先在调用对象的类（这里是 TestB）中查找。
向上查找基类： 如果在当前类中没有找到匹配的函数，编译器会沿着继承链向上查找基类。
名称隐藏： 如果派生类中声明了一个与基类中函数同名的函数，即使它们的参数列表不同，派生类中的函数也会隐藏基类中的所有同名函数。即编译器不会继续在基类中查找。

因此，名称隐藏发生的根本原因在于，编译器在派生类中找到同名成员后，就会停止查找，不再继续在基类中查找。换句话说，派生类中的名称会屏蔽或隐藏基类中同名名称的可见性。

在本例中，具体流程如下：

编译器在 TestB 类中查找名为 getName 且接受一个 int 类型参数的函数。
编译器没有找到签名匹配的函数，但找到了 getName(int x, int y)。因为有同名函数，所以停止继续在基类查找。
编译器尝试进行隐式类型转换，试图将一个 int 类型的参数 1 转换为可以用于调用 getName(int x, int y) 的参数组合。但因为数量不匹配，所以转换失败。
编译器报错，提示没有匹配的函数可以调用。

四、如何避免名称隐藏问题？

（1）使用 using 声明 可以将基类中的特定函数引入派生类的作用域。例如：

template<class T>
class TestB : public TestA<T> {
public:
    TestB(string name) : TestA<T>(name) {}
    // Bring the base class getName functions into scope.
    using TestA<T>::getName; 
protected:
    string getName(int x, int y) const {
        return TestA<T>::getName() + "B";
    }
};

通过添加 using TestA<T>::getName;，我们将 TestA 中的 getName 函数引入 TestB 的作用域，现在 b.getName(1) 就可以正确调用 TestA::getName(int x) 了。

（2）使用作用域解析运算符 :: 可以显式指定要调用的函数来自哪个类。例如：

cout << b.TestA<int>::getName(1) << endl; // 显式调用基类中的函数

这种方法可以直接告诉编译器调用 TestA 类中的 getName(int x) 函数。

特别说明：

避免在派生类中使用与基类函数同名的函数，除非确实希望覆盖 (override) 基类函数。如果函数有不同的功能，尽量使用不同的名称。
如果派生类中的函数确实想要替换基类中的函数，确保使用 override 关键字进行标记（从 C++11 开始）。尽管此关键字不直接解决名称隐藏问题，但它可以帮助你确保你确实是在有意识地覆盖基类函数，而不是意外地隐藏它。要使用 override, 基类的函数必须是 virtual 函数。