Question

在C ++中，函数是覆盖运行时多态还是编译时多态？？我认为这是编译时多态，因为调用适当函数所需的所有信息都早已为编译器所知。如下代码所示，obj.disp();在这里，编译器知道obj是基类的对象，因此它将立即解决对基类disp()函数的调用。与obj2.disp();相同，这里编译器知道obj2是派生类的对象，因此它将调用派生类的disp（）函数。我不明白为什么将其称为运行时多态。

仍然在JAVA中，人们将函数重写称为运行时多态。请向某人解释。...

#include <iostream>
using namespace std;

class A {
public:
  void disp(){
     cout<<"Super Class Function"<<endl;
  }
};

class B: public A{
public:
  void disp(){
     cout<<"Sub Class Function";
  }
};

int main() {
  //Parent class object
  A obj;
  obj.disp();
  //Child class object
  B obj2;
  obj2.disp();
  return 0;
}

Answer 1

在运行时仅解析虚拟函数调用。如果函数不是虚函数（如您的示例所示），则在编译时解决调用。

查看未优化的程序集（由gcc 9.2使用-O0生成），主要功能被编译为：

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        lea     rax, [rbp-1]
        mov     rdi, rax
        call    _ZN1A4dispEv
        lea     rax, [rbp-2]
        mov     rdi, rax
        call    _ZN1B4dispEv
        mov     eax, 0
        leave
        ret

奇怪的名称_ZN1A4dispEv和_ZN1B4dispEv是名称修改的结果：在这种情况下，编译器会为函数创建唯一的名称（请记住，在汇编中没有oop）。实际的处理是由编译器定义的，但是您会注意到类的名称（分别为A和B）和函数的名称disp。

如果在disp中将virtual声明为A，则main看起来像：

main:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
->      mov     eax, OFFSET FLAT:vtable for A+16
->      mov     QWORD PTR [rbp-8], rax
        lea     rax, [rbp-8]
        mov     rdi, rax
        call    A::disp()
->      mov     eax, OFFSET FLAT:vtable for B+16
->      mov     QWORD PTR [rbp-16], rax
        lea     rax, [rbp-16]
        mov     rdi, rax
        call    B::disp()
        mov     eax, 0
        leave
        ret

标记为->的行是vtable查询，用于在运行时解析函数调用。

Answer 2

函数是覆盖运行时多态还是编译时多态

您只能使用override个虚拟方法，这些方法在那里支持运行时多态性。如果在编译时知道所有事实，那么聪明的编译器可能无需vtables（对于虚拟调度）就可以进行管理，但是如果不知道，则必须在运行时解决。

让随机数生成器从不同的子类创建对象，并将它们传递给接受基类指针（或引用）的函数，该函数仍将能够调用该对象的重写函数。这是在运行时解决的。隐藏基类函数或子类重载的函数将不可用。

一个例子（无随机数）：

#include <iostream>

class Foo {
public:
    void not_virtual() { std::cout << "not_virtual\n"; }
    virtual void func() = 0;

    virtual ~Foo() = 0;
};

Foo::~Foo() {}

void Foo::func() {
    std::cout << "default implementation\n";
}

class FooImpl : public Foo {
public:
    void not_virtual() {      // hiding - Foo's not_virtual()
        std::cout << "not_virtual, but in FooImpl\n";
    }
    void not_virtual(int x) { // overloading - same name, different signature
        std::cout << "not_virtual " << x << "\n";
    }
    void func() override { std::cout << "Impl\n"; }
};

void interface_user(Foo& x) { // slice away all but the Foo part of the object
                              // but
    x.func();                 // func() is in the vtable, call child class' function
    x.not_virtual();          // not in the vtable, call Foo's function
    // x.not_virtual(2);      // error: Foo doesn't have this overload
}

int main() {
    FooImpl f;

    f.func();          // calling overridden func
    f.not_virtual();   // calling function hiding the base class function
    f.not_virtual(1);  // calling overloaded func

    interface_user(f); // slicing - the function takes a Foo&
}

输出：

Impl
not_virtual, but in FooImpl
not_virtual 1
Impl
not_virtual

在C ++中重写的方法：是编译时还是运行时多态？

2 个答案: