具有不同参数类型的虚函数

Question

我正在尝试了解虚函数的工作原理，但卡在了某个部分。

我写过这个小程序：

class First
{
public:
    virtual void f(int a) 
    {
        cout << "First!" << endl;
        cout << a << endl;
    }
};

class Second : public First
{
public:
    void f(int a) {
        cout << "Second!" << endl;
        cout << a << endl;
    }
};

void main() {
    Second s;
    First *p = &s;
    p->f(5);
    First n;
    p = &n;
    p->f(3);
    _getch();
}

此代码导致：

Second!
5
First!
3

但是，如果我将 Second::f() 函数中的 int 更改为不同的类型，如下所示：

class First
{
public:
    virtual void f(int a) {
        cout << "First!" << endl;
        cout << a << endl;
    }
};

class Second : public First
{
public:
    void f(double a) { //double instead int here!
        cout << "Second!" << endl;
        cout << a << endl;
    }
};

void main() {
    Second s;
    First *p = &s;
    p->f(5);
    First n;
    p = &n;
    p->f(3);
    _getch();
}

我的程序从不调用 Second::f()，结果是：

First!
5
First!
3

有人可以向我解释为什么会这样吗？

Answer 1

事实上，派生的 classes 不会重新声明基 classes 的虚函数。他们重新定义了它们，在 C++ 的术语中意味着覆盖基 classes.

的虚函数的定义

在您的第二个示例中，派生 class 声明了一个新的非虚函数（因为函数说明符 virtual 不存在），其名称与基 [=26= 中的虚函数的名称相同].新声明的函数隐藏了基class.

中虚函数的声明

在此代码段中

Second s;
First *p = &s;
p->f(5);

指针p的静态类型是First。所以编译器通过classFirst中声明的虚函数table查找，找到指向classFirst中声明的函数的指针。此指针未被派生 class 中虚函数的地址覆盖，因为派生 class 未覆盖基 class 函数。

如果你会写例如

Second s;
Second *p = &s;
^^^^^^
p->f(5);

然后调用派生class中声明的非虚函数。

Answer 2

在第二段代码中，Second继承了一个名为f()的虚函数，并有自己的函数也叫f()。

现在，由于所有调用都是从 First（或 First 指向的对象）完成的，因此它的工作方式如下：当您从 First 对象调用时，很明显 First 中的函数将被调用。现在，当您从指向 First 的指针指向的 Second 对象调用时，由于 f() 是虚拟的，"compiler" [请参阅下面的评论] 在实际 class 中搜索它（其中是 Second) 但由于那里没有匹配 void f(int) 的函数，因此它从 First 中获取一个。

Answer 3

当使用虚函数调度时，所谓的"final overrider"就是被调用的。对于一个甚至覆盖继承的虚函数的函数，它必须满足一些条件：

If a virtual member function vf is declared in a class Base and in a class Derived, derived directly or indirectly from Base, a member function vf with the same name, parameter-type-list (8.3.5), cv-qualification, and refqualifier (or absence of same) as Base::vf is declared, then Derived::vf is also virtual (whether or not it is so declared) and it overrides Base::vf.

-- ISO/IEC 14882:2001(E) §10.3（粗体强调我的）

很简单，在您的第二个示例中，Second::f(double) 的参数列表与 First::f(int) 的参数列表不同，因此 Second::f(double) 是 而不是 （自动）虚拟并且不覆盖First::f(int).

C++11 关键字 override 声明了您的意图，即方法重写继承的虚方法，以便编译器可以在不重写时告诉您。例如，如果您改为这样做：

void f(double a) override {

编译器会给你这个诊断来告诉你它实际上并没有覆盖任何东西，它甚至会告诉你为什么它没有（"type mismatch at 1st parameter ('int' vs 'double')"):

main.cpp:15:18: error: non-virtual member function marked 'override' hides virtual member function
void f(double a) override { //double instead int here!
                 ^
main.cpp:7:14: note: hidden overloaded virtual function 'First::f' declared here: type mismatch at 1st parameter ('int' vs 'double')
virtual void f(int a) {
             ^

具有不同参数类型的虚函数

Virtual functions with different argument types

c++

inheritance

virtual-functions

class