使用默认参数解析虚拟功能 [英] Resolution of virtual function with default parameters

问题描述

header.h

#include <iostream>
using namespace std;
class A
{
    public:
        virtual void display(int i=5) { cout<< "Base::" << i << endl; }
};

class B : public A
{
    public:
        void display(int i=9) { cout<< "Derived::" << i << endl; }
};  

source.h

#include <iostream>
#include "header.h"
using namespace std;
int main()
{
    A * a = new B();
    a->display();

    A* aa = new A();
    aa->display();

    B* bb = new B();
    bb->display();
}  

输出

Derived::5
Base::5
Derived::9  

我的理解是，默认参数函数是在编译期间使用函数重载解决的.然后，在运行时使用函数覆盖来解析虚拟函数.

My understanding was default parameter functions were resolved during compile time using function overloading. Virtual functions were then resolved during runtime using function overriding.

但是发生的是一团糟.
函数解析实际上是如何发生的?

But what is happening is a mess.
How does the function resolution actually happen here?

推荐答案

实际上，编译器会看到您的代码，如下所示:
(实际上不存在 display()方法，但是解析方式类似)

Your code is actually seen by the compiler like this:
(The display() method is not actually there, but the resolving works in similar way)

class A
{
public:
    virtual void display(int i) { cout<< "Base::" << i << endl; }
    void display() { display(5); }
};

class B : public A
{
public:
    void display(int i) override { cout<< "Derived::" << i << endl; }
    void display() { display(9); }
};

现在您应该了解会发生什么.您正在调用非虚拟的 display()，它会调用虚拟函数.更严格地说:解析默认参数就像使用no-arg非虚拟方法一样-根据变量的类型(而不是对象的实际类型)，但是代码是根据虚拟对象类型执行的，因为它是虚拟方法:

Now you should understand what happens. You are calling the non-virtual display() which calls the virtual function. In more strict words: the default argument is resolved just like if the no-arg non-virtual method was there - by the type of the variable (not by the actual type of the object), but the code gets executed according to real object type, because it is virtual method:

int main()
{
    A * a = new B(); // type of a is A*   real type is B
    a->display();    // calls A::display() which calls B::display(5)

    A* aa = new A(); // type of aa is A*  real type is A
    aa->display();   // calls A::display() which calls A::display(5)

    B* bb = new B(); // type of bb is B*  real type is B
    bb->display();   // calls B::display() which calls B::display(9)
}  

这篇关于使用默认参数解析虚拟功能的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！