为什么即使对象指针在多重继承中不同，情况也是一样的？

Question

当使用多重继承时，C++ 必须维护多个 vtable，这导致对公共基类有“多个视图”。

这是一个代码片段：

#include "stdafx.h"
#include <Windows.h>

void dumpPointer( void* pointer )
{
    __int64 thisPointer = reinterpret_cast<__int64>( pointer );
    char buffer[100];
   _i64toa( thisPointer, buffer, 10 );
    OutputDebugStringA( buffer );
    OutputDebugStringA( "\n" );
}

class ICommonBase {
public:
    virtual void Common() = 0 {}
};

class IDerived1 : public ICommonBase {
};

class IDerived2 : public ICommonBase {
};

class CClass : public IDerived1, public IDerived2 {
public:
    virtual void Common() {
        dumpPointer( this );
    }
    int stuff;
};

int _tmain(int argc, _TCHAR* argv[])
{
    CClass* object = new CClass();
    object->Common();
    ICommonBase* casted1 = static_cast<ICommonBase*>( static_cast<IDerived1*>( object ) );
    casted1->Common();
    dumpPointer( casted1 );

    ICommonBase* casted2 = static_cast<ICommonBase*>( static_cast<IDerived2*>( object ) );
    casted2->Common();
    dumpPointer( casted2 );

    return 0;
}

它产生以下输出：

206968 //CClass::Common this
206968 //(ICommonBase)IDerived1::Common this
206968 //(ICommonBase)IDerived1* casted1
206968 //(ICommonBase)IDerived2::Common this
206972 //(ICommonBase)IDerived2* casted2

这里 casted1 和 casted2 具有不同的值，这是合理的，因为它们指向不同的子对象。当虚函数被调用时，到基类的转换已经完成，编译器不知道它最初是一个最派生的类。不过这个每次都是一样的。这是怎么发生的？

Answer 1

当在虚函数调用中使用多重继承时，对虚函数的调用通常会转到调整 this 指针的“thunk”。在您的示例中，casted1 指针的 vtbl 条目不需要 thunk，因为 CClass 的 IDerived1 子对象恰好与CClass 对象的开始（这就是 casted1 指针值与 CClass object 指针相同的原因）。

但是，指向 IDerived2 子对象的 casted2 指针与 CClass 对象的开头不一致，因此 vtbl 函数指针实际上指向 thunk 而不是直接指向 CClass::Common() 函数。 thunk 调整 this 指针以指向实际的 CClass 对象，然后跳转到 CClass::Common() 函数。因此，无论从哪种类型的子对象指针调用它，它总是会获得指向 CClass 对象开头的指针。

Stanley Lippman 的“Inside the C++ Object Model”对此有很好的解释本书，第 4.2 节“虚拟成员函数/MI 下的虚拟函数”。

Answer 2

当转换为不同类型时，字段的偏移量以及 vtable 中的条目必须位于一致的位置。采用 ICommonBase* 作为参数的代码不知道您的对象实际上是 IDerived2。但它仍然应该能够取消引用 ->foo 或调用虚拟方法 bar()。如果这些地址不在可预测的地址，则无法工作。

对于单一继承的情况，这很容易得到正确的结果。如果Derived继承自Base，你可以说Derived的偏移0也是Base的偏移0， Derived 特有的成员可以位于 Base 的最后一个成员之后。对于多重继承，显然这是行不通的，因为 Base1 的第一个字节不能也是 Base2 的第一个字节。每个人都需要自己的空间。

因此，如果您有这样一个继承自两个的类（称之为 Foo），编译器可以知道对于类型 Foo，Base1部分从偏移量 X 开始，Base2 部分从偏移量 Y 开始。当转换为任一类型时，编译器只需向 this 添加适当的偏移量即可。

当调用 Foo 的实际虚拟方法时，其中实现由 Foo 提供，它仍然需要指向该对象的“真实”指针，以便它可以访问所有其成员，而不仅仅是基 Base1 或 Base2 的特定实例。因此，this 仍然需要指向“真实”对象。

请注意，其实现细节可能与描述的不同，这只是问题存在原因的高级描述。

Answer 3

如果您看到内存中的对象布局，它将是这样的：

v-pointer for IDerived1
v-pointer for IDerived2
....
....

也可以是其他方式..但只是为了提供一个想法..

您的 this 将始终指向对象的开头即 IDerived1 的 v 指针存储的位置。但是，当您将指针强制转换为 IDerived2 时，强制转换的指针将指向 IDerived2 的 v 指针，该指针将从 this 偏移 sizeof(pointer) 指针。

Answer 4

G++ 4.3 中有相同的对象模型，如您所示，（参见 Naveen 的回答）说casted1和casted2具有不同的值。

此外，在 G++ 4.3 中，即使您使用残酷的转换：

ICommonBase* casted1 = (ICommonBase*)(IDerived1*)object; 
ICommonBase* casted2 = (ICommonBase*)(IDerived2*)object;

结果也是一样的。

编译器非常聪明