覆盖虚函数和隐藏非虚函数有什么区别？

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

什么是函数隐藏？

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

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
    }
};

---

什么是函数覆盖？

这与虚函数的概念有关。 [class.virtual]/2

如果一个虚成员函数vf在类Base和类Derived中声明，直接或间接派生自Base，则成员函数vf同名，参数类型-list、cv-qualification 和 ref-qualifier（或不存在相同）作为 Base::vf 已声明，然后 Derived::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 是基类子对象（如果有）声明或继承另一个覆盖@987654337 的成员函数@。

即如果您有一个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)`
};

Answer 2

调用 virtual 成员函数和调用 non-virtual 成员函数的区别在于，根据定义，在前一种情况下，目标函数是根据在调用中使用对象表达式的 dynamic 类型，而在后一种情况下使用 static 类型。

仅此而已。您的示例通过p2->doA() 和p2->doB() 调用清楚地说明了这种差异。 *p2 表达式的静态类型为Parent，而同一表达式的动态类型为Child。这就是p2->doA() 调用Parent::doA 和p2->doB() 调用Child::doB 的原因。

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

Answer 3

我们将从简单的开始。

p1 是一个Parent 指针，所以它总是会调用Parent 的成员函数。

cp 是一个指向Child 的指针，所以它总是会调用Child 的成员函数。

现在难度更大了。 p2 是一个Parent 指针，但它指向一个Child 类型的对象，所以只要匹配的Parent 函数是虚函数或者该函数只存在于@987654332 中，它就会调用Child 的函数@ 而不是Parent。换句话说，Child 用自己的doA() 隐藏了Parent::doA()，但它覆盖了Parent::doB()。函数隐藏有时被认为是函数重载的一种形式，因为同名的函数被赋予了不同的实现。因为隐藏函数与隐藏函数在不同的类中，所以它确实有不同的签名，这使得使用哪个更清楚。

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;
}

在cp->doX() 调用时通过输出证明这一点

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

另外，cp->Parent::doA() 将调用Parent 的doA() 版本。

p2 不能引用doX()，因为它是Parent*，而Parent 不知道Child 中的任何内容。但是，p2 可以强制转换为Child*，因为它被初始化为 1，然后它可以用来调用doX()。

Answer 4

一个更简单的例子，它与所有这些都不同。

class Base {
public:
    virtual int fcn();
};

class D1 : public Base {
public:  
    // D1 inherits the definition of Base::fcn()
    int fcn(int);  // parameter list differs from fcn in Base
    virtual void f2(); // new virtual function that does not exist in Base
};

class D2 : public D1 {
public:
    int fcn(int); // nonvirtual function hides D1::fcn(int)
    int fcn();  // overrides virtual fcn from Base
    void f2();  // overrides virtual f2 from D1
}

Answer 5

您在问题中编写的示例代码在您运行它时基本上给出了答案。

调用非虚函数将使用与指针类型相同的类中的函数，无论对象是否实际创建为其他派生类型。而调用虚函数将使用原始分配对象类型中的函数，而不管您使用的是哪种指针。

所以你的程序在这种情况下的输出将是：

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