c++ - XY从X和Y继承。将XY *转换为X *然后转换为Y *，然后调用Y的函数将导致调用X的函数

Question

#include <iostream>

struct X
{
    virtual void x() = 0;
};

struct Y
{
    virtual void y() = 0;
};

struct XY : X, Y
{
    void x() override { std::cout << "X\n"; }
    void y() override { std::cout << "Y\n"; }
};

int main()
{
    XY xy;

    X* xptr = &xy;

    Y* yptr = (Y*)xptr;

    yptr->y(); //prints "X"....

    ((Y*)((X*)(&xy)))->y(); // prints "Y"....
}

输出:

X
Y

有人可以详细解释为什么会这样吗？为什么第一个 call 正在打印 X，以及为什么两个 call 彼此不同？

Answer 1

如评论中所述，就语言而言，这是未定义行为。

但是，实际选择的行为的确揭示了典型C++编译器的内部工作原理，因此研究为什么获得输出仍然很有趣。但是，重要的是要记住，以下解释不是通用的。并没有要求以这种方式工作的任何硬性要求，并且依赖于这种方式的代码有效地被破坏了，即使您在上尝试过的所有编译器都可以使用。

C++多态性通常是使用vtable实现的，该表基本上是函数指针的列表，并且可以看作对象中的隐藏成员指针。

所以

struct X
{
 virtual void x() = 0;
};

struct Y {
 virtual void y() = 0;
};

大致等效于(实际上并没有使用std::function<>，但这使伪代码更易读):

struct X {
    struct vtable_t {
      std::function<void(void*)> first_virtual_function;
    };

    vtable_t* vtable;

    void x() {
      vtable->first_virtual_function(this);
    }
};

struct Y {
    struct vtable_t {
      std::function<void(void*)> first_virtual_function;
    };

    vtable_t* vtable;

    void y() {
      vtable->first_virtual_function(this);
    }
};

注意X::vtable_t和Y::vtable_t是的巧合，而本质上是同一件事。如果X和Y具有不同的虚函数，那么事情就不会整齐地排列起来。

难题的另一个重要方面是，多重继承实际上是一个串联:

struct XY : X, Y {
    void x() override { std::cout << "X\n"; }
    void y() override { std::cout << "Y\n"; }
};

// is roughly equivalent to:
struct XY {
  static X::vtable vtable_for_x; // with first_virtual_function assigned to XY::x()
  static Y::vtable vtable_for_y; // with first_virtual_function assigned to XY::y()

  X x_base;
  Y y_base;

  XY() {
    x_base.v_table = &vtable_for_x;
    y_base.v_table = &vtable_for_y;
  }

  void x() { std::cout << "X\n"; }
  void y() { std::cout << "Y\n"; }
};

这意味着从多重继承类型转换为基数不仅是更改指针类型的问题，而且值也必须更改。

仅X指针等效于基础对象指针，Y指针实际上是一个不同的地址。

X* xptr = &xy;  
// is equivalent to
X* xptr = &xy->x_base;

Y* xptr = &xy;  
// is equivalent to
Y* xptr = &xy->y_base;

最后，当您从X转换为Y时，由于这些类型是不相关的，因此该操作是reinterpret_cast，因此尽管指针可能是Y的指针，但基础对象仍然是X。

幸运的是，事情接line而至:

X和Y都将vtable指针作为第一个成员对象。

X和Y的vtable实际上等效，前者指向XY::x()，后者指向XY::y()。

因此，当将y()的调用逻辑应用于X类型的对象时，这些位恰好排成一行，而是调用XY::x()。