Question

在During construction and destruction的示例中：

struct V {
    virtual void f();
    virtual void g();
};

struct A : virtual V {
    virtual void f(); // A::f is the final overrider of V::f in A
};
struct B : virtual V {
    virtual void g(); // B::g is the final overrider of V::g in B
    B(V*, A*);
};
struct D : A, B {
    virtual void f(); // D::f is the final overrider of V::f in D
    virtual void g(); // D::g is the final overrider of V::g in D

    // note: A is initialized before B
    D() : B((A*)this, this) 
    {
    }
};


B::B(V* v, A* a)
{
    f(); // virtual call to V::f (although D has the final overrider, D doesn't exist)
    g(); // virtual call to B::g, which is the final overrider in B 

    v->g(); // v's type V is base of B, virtual call calls B::g as before

    a->f(); // a’s type A is not a base of B. it belongs to a different branch of the
            // hierarchy. Attempting a virtual call through that branch causes
            // undefined behavior even though A was already fully constructed in this
            // case (it was constructed before B since it appears before B in the list
            // of the bases of D). In practice, the virtual call to A::f will be
            // attempted using B's virtual member function table, since that's what
            // is active during B's construction)
}

问题1：为什么v->g()呼叫B::g()？
问题2：这是什么意思？

将使用B的虚拟成员函数表尝试对A :: f的虚拟调用，因为这是在B的构造期间 active 的功能。

Answer 1

在C ++中，访问未构造的对象是未定义的。为了避免这种不确定的行为，对象在构造期间指向不同的虚拟表（vtable）。如果存在Base和Derived类，则对象最初指向vtable Base。稍后当Derived开始构建时，vtable指向`Derived。最后，此答案与问题2的答案一起进行了解释。

相同的规则适用于虚拟继承。但是，在虚拟继承的情况下，构造顺序与常规继承不同，并且vtable遵循该构造顺序。

在您的情况下，您需要进行以下操作：

B::B(V* v, A* a)

和

D() : B((A*)this, this)  // in class D

这意味着在构造D之前，它会构造其父B。 B::B被this强制转换为A*和D*。在B::B时，D的构造函数尚未启动，因此vtable并未指向D的方法。该对象指向更早的vtable。对象使用哪个vtable的问题取决于零件的构造顺序。

首先构建虚拟基础，在这种情况下，仅构建V。其余的照常。这意味着顺序为V->A->B->D。

以下是代码中不同函数调用的列表：

f()-D尚未构建，因此无法调用D::f()，并且vtable不会指向它。 A不是B的基数，因此不会调用A::f()。剩下的唯一选项是V::f()。注意，给定一个指向对象的指针，就不会调用同级的虚函数。只是对象的最派生方法，它的父母和孩子（一直到对象的动态类型）。
g()-D尚未构建，因此无法调用D::g()。由于这是B的构造函数，因此它可以访问其所有方法，因此称为B::g()。
v->g()-v的类型为V，并且可以通过虚拟方法机制调用其中一个子类的g()。 D尚未构建，因此D::g()尚未在vtable中。由于这是B的构造函数，因此vtable已更新为指向B的方法和所有已构造的部分（A和V）。因此，vtable指向B::g()。
a->f()-a的类型为A，因此它可能会调用其父类的方法，而不是其子类D的方法，因为它尚未被构造。这意味着V::f()或A::f()。由于虚拟方法调用首选使用派生程度最高的方法，因此应调用A::f()。

我已经回答了第一个原始问题：

为什么v->g()呼叫B::g()？

等等。

对于第二个问题，有关以下含义：

将使用B的虚拟成员函数表尝试对A :: f的虚拟调用，因为这是在B的构造期间处于活动状态的
。

以上内容讨论了虚拟函数调用的概念模型。虚拟函数调用是通过指向方法的指针数组进行的，即所谓的“ 虚拟表”，即vtable。对于每个虚函数，例如您的示例中的f()，编译后的代码将从此vtable中获取方法的指针。这是非常便宜的，因为它是对数组的简单索引访问。派生类的对象具有不同的vtable，其中某些方法指针不同。

获得指向父对象的指针的代码，并不关心它是父对象还是子对象。它只是从O（1）的vtable中的给定索引获取方法指针，而不管对象的真实类型如何。在构造函数中从父类更改为子类的类型，是通过简单恒定时间地重新分配指向vtable的指针来实现的。引用的文字是指使指针指向不同vtable的事件序列。

通过虚拟继承，在给定时间可以有多个活动的vtable。根据执行方法调用的类型（例如，通过B，A或V）选择vtable。

文本的措辞涉及使用B的vtable调用A::f，这没有任何意义。甚至示例代码都说，在B::B中调用f()会调用V::f()而不是A::f()。我认为应该通过B的vtable执行文本V::f()，这与我写的内容一致。

构建过程中的虚拟函数调用

1 个答案: