C++：隐藏规则背后的基本原理

Question

隐藏规则背后的基本原理是什么C++？

class A { void f(int); }
class B : public A { void f(double); } // B::f(int) is hidden

• 如果这是一个有意义的功能，我认为也应该可以隐藏函数而无需定义具有相同名称的新函数：如下所示：

   class B : public A { hide void f(double); }
  

但这不可能。

• 我认为它不会简化编译器的工作，因为当您显式使用 using 指令时，编译器必须能够取消隐藏函数：

   class B : public A { using A::f;无效 f(双精度); } // B::f(int) 不隐藏
  

那么，为什么会有隐藏规则？

Answer 1

这是一个棘手的问题，但显然这个想法是，这种隐藏功能有助于避免在更改基类时出现微妙的错误（否则可能会“窃取”之前由派生类处理的调用）。基类的更改仍然会影响派生类的编译结果，所以我认为我不能 100% 理解这个解释。

我同意这个话题被如此频繁地讨论，以至于隐藏实际上可能增加了 C++ 程序员的“惊喜”数量。

有关此问题的详细讨论可以在此处< /a>...

Answer 2

我不知道最初的理由，但因为隐藏或不隐藏都是同样糟糕的选择。对于函数，我猜其基本原理是具有统一规则：与嵌套大括号范围中定义的名称相同。

隐藏在某些方面对你有帮助。

默认情况下，向基类添加方法不会影响派生类的重载解析。

并且您不会因某些意外将带有参数 false 的调用定向到具有形式参数 void* 的基类方法而与重载解析发生冲突。这样的事情。

干杯&呵呵，

Answer 3

我确信我见过 C++ 大佬提供的这个案例，但不确定是哪个：

struct Base {
    void f(const Base&);
};

struct Derived : Base {
    using Base::f;
    void f(double);
};

int main() {
    Derived d;
    d.f('a'); // calls Derived::f
}

现在，在 Base 中添加 void f(int);，以及其含义主要变化 - 它调用 Base::f 因为 int 更适合 char - 它是整数提升而不是标准转换。

目前尚不清楚对基址的更改是否真的是程序员有意捕获使用 char 的调用，因此要求 using 是显式的意味着默认行为是更改不会影响调用代码。我相信这是一个边际呼吁，但我认为委员会认为 C++ 中的基类本身就足够脆弱，没有这个:-)

不需要“隐藏”关键字，因为没有隐藏“f”的类似情况当 Derived 中未重载时，来自 Base。

顺便说一句，我选择了类型，而 char 是故意不协调的。您可以使用 int 与 unsigned int 而不是 int 与 char 来获得更微妙的情况。

Answer 4

隐藏基类的成员函数（具有相同名称但不同签名）的另一个原因可能是由于可选参数引起的歧义。考虑下面的例子：

#include <stdio.h>

class A
{
public:
    int foo(int a, int b=0)
    {
        printf("in A : %d, %d\n", a, b);
    }
};

class B : public A
{
public:
    int foo(int a)
    {
        printf("in B : %d\n", a);
        foo(a); //B:foo(a) will be called unless we explicitly call A:foo(a)
        foo(a, 1); // compile error: no matching function for call to B:foo(int&, int)
    }
};


int main()
{
    B b;
    b.foo(10);
    return 0;
}

如果基类中的 foo 方法没有被隐藏，编译器就不可能决定是否应该调用 A::foo或 B::foo 因为以下行匹配两个签名：

foo(a);

Answer 5

原因可能是模板专业化。我举个例子：

template <int D> struct A { void f() };

template <> struct A<1> { void f(int) };

template <int D>
struct B: A<D>
{
  void g() { this->f(); }
};

模板类 B 有一个方法 f()，但是在您不创建类 B 的实例之前，您不知道其签名。因此，调用 this->f() 任何时候都是“合法的”。在创建实例之前，GCC 和 CLang 都不会报告错误。但是，当您在 B<1> 实例上调用方法 g() 时，它们会指示错误。因此，隐藏规则可以更简单地检查您的代码是否有效。

我报告了示例中使用的代码的最后一部分。

int main (int argc, char const *argv[])
{
  B<0> b0; /* valid */
  B<1> b1; /* valid */

  b0.g(); /* valid */
  b1.g(); /* error: no matching function for call to ‘B<1>::f()’ */

  return 0;
}