重写虚函数和隐藏非虚函数有什么区别？

Question

给定下面的代码片段，函数调用有什么不同？什么是函数隐藏？什么是函数覆盖？它们与函数重载有什么关系？两者有什么区别？我在一个地方找不到关于这些的很好的描述，所以我在这里询问，这样我可以整合信息。

class Parent {
  public:
    void doA() { cout << "doA in Parent" << endl; }
    virtual void doB() { cout << "doB in Parent" << endl; }
};

class Child : public Parent {
  public:
    void doA() { cout << "doA in Child" << endl; }
    void doB() { cout << "doB in Child" << endl; }
};

Parent* p1 = new Parent();
Parent* p2 = new Child();
Child* cp = new Child();

void testStuff() {
  p1->doA();
  p2->doA();
  cp->doA();

  p1->doB();
  p2->doB();
  cp->doB();
}

Answer 1

匿名用户

我们从简单的开始。

< code>p1是一个< code>Parent指针，因此它将始终调用< code>Parent的成员函数。

cp 是指向 Child 的指针，因此它将始终调用 Child 的成员函数。

现在是更困难的一个p2是Parentpointer，但它指向Child类型的对象，因此只要匹配的 函数是虚拟的，或者该函数只存在于 中，而不存在于 中，它就会调用 0.05 Child的函数。换句话说，Child使用自己的doA（）隐藏Parent:：doA（。函数隐藏有时被认为是函数重载的一种形式，因为同名的函数被赋予不同的实现。因为隐藏函数与隐藏函数位于不同的类中，所以它确实具有不同的签名，这使得使用哪一个更为明确。

testStuff（） 的输出将是

doA in Parent
doA in Parent
doA in Child
doB in Parent
doB in Child
doB in Child

在任何情况下，Parent:：doA（）和Parent:：doB（）都可以使用名称解析在Child中调用，而不考虑函数的“虚拟性”。函数

void Child::doX() {
  doA();
  doB();
  Parent::doA();
  Parent::doB();
  cout << "doX in Child" << endl;
}

由< code>cp-调用时演示这一点

doA in Child
doB in Child
doA in Parent
doB in Parent
doX in Child

此外，< code>cp-

p2不能引用doX（），因为它是 Parent不知道 p2 可以被强制转换为Child*，因为它被初始化为一个，然后可以用来调用doX（）。

Answer 2

调用虚成员函数和调用非虚成员函数的区别在于，根据定义，在前一种情况下，目标函数是根据调用中使用的对象表达式的动态类型选择的，而在后一种情况下，使用的是静态类型。

这就是一切。您的示例通过p2清楚地说明了这种差异-

在这种差异很重要的情况下，姓名隐藏根本不会出现。

Answer 3

...是名称隐藏的一种形式。一个简单的例子：

void foo(int);
namespace X
{
    void foo();
    
    void bar()
    {
        foo(42); // will not find `::foo`
        // because `X::foo` hides it
    }
}

这也适用于基类中的名称查找：

class Base
{
public:
    void foo(int);
};

class Derived : public Base
{
public:
    void foo();
    void bar()
    {
        foo(42); // will not find `Base::foo`
        // because `Derived::foo` hides it
    }
};

这与虚拟功能的概念有关。[类.虚拟]/2

如果虚拟成员函数vf在类Base中声明，并且在直接或间接从Base派生的类中声明，则声明具有与Base::vf相同的名称、参数类型列表、cv资格和参考限定符（或不存在相同）的成员函数vf，则ed::vf也是虚拟的（无论是否如此声明）并且它覆盖Base::vf。

class Base
{
private:
    virtual void vf(int) const &&;
    virtual void vf2(int);
    virtual Base* vf3(int);
};

class Derived : public Base
{
public: // accessibility doesn't matter!
    void vf(int) const &&; // overrides `Base::vf(int) const &&`
    void vf2(/*int*/);     // does NOT override `Base::vf2`
    Derived* vf3(int);     // DOES override `Base::vf3` (covariant return type)
};

调用虚拟函数时，最后一个重写器变得相关：[class.virtual]/2

类对象S的虚拟成员函数C::vf是最终的覆盖器，除非最底层的派生类S是基类子对象（如果有）声明或继承另一个覆盖vf的成员函数。

也就是说，如果你有一个 S 类型的对象，则最终的覆盖器是你在遍历 S 的类层次结构回到其基类时看到的第一个覆盖器。重要的一点是，函数调用表达式的动态类型用于确定最终覆盖器：

Base* p = new Derived;
p -> vf(42);    // dynamic type of `*p` is `Derived`

Base& b = *p;
b  . vf(42);    // dynamic type of `b` is `Derived`

本质上，基类中的函数总是被派生类中同名的函数隐藏；无论派生类中的函数是否重写基类的虚函数:

class Base
{
private:
    virtual void vf(int);
    virtual void vf2(int);
};

class Derived : public Base
{
public:
    void vf();     // doesn't override, but hides `Base::vf(int)`
    void vf2(int); // overrides and hides `Base::vf2(int)`
};

要查找函数名，使用表达式的静态类型：

Derived d;
d.vf(42);   // `vf` is found as `Derived::vf()`, this call is ill-formed
            // (too many arguments)

因为“函数隐藏”是名称隐藏的一种形式，所以如果函数的名称被隐藏，所有重载都会受到影响:

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
};

class Derived : public Base
{
public:
    void vf();     // hides `Base::vf(int)` and `Base::vf(double)`
};

对于函数重写，只有基类中具有相同参数的函数才会被重写；当然，您可以重载虚拟函数：

class Base
{
private:
    virtual void vf(int);
    virtual void vf(double);
    void vf(char);  // will be hidden by overrides in a derived class
};

class Derived : public Base
{
public:
    void vf(int);    // overrides `Base::vf(int)`
    void vf(double); // overrides `Base::vf(double)`
};