处理多重继承时如何对齐指针？

Question

假设我们有一个具体的类 A 和一个抽象类 B。

考虑一个具体的 C，它继承自 A 和 B，并实现 B：

class C : public A, public B  
{  
/* implementation of B and specific stuff that belongs to C */  
};

现在我定义一个函数，其签名为 void foo(B* b);

这是我的代码，我可以假设每个指向 B 的指针都是 A 和 B。 在foo的定义中，如何获取指向A的指针？ 一个令人讨厌但有效的技巧是像这样对齐后向指针：

void foo(B* b)  
{  
    A* a = reinterpret_cast<A*>(reinterpret_cast<char*>(b) - sizeof(A));
    // now I can use all the stuff from A  
}

请记住，C 没有超类型，实际上，有许多类似于 C 的类，它们只有 A 和 B。请随意质疑我的逻辑和这个设计示例也是如此，但问题仅涉及指针对齐。

Answer 1

void foo(B* b)  
{  
    //A* a = reinterpret_cast<A*>(reinterpret_cast<char*>(b) - sizeof(A)); // undefined behaviour!!!!
    A* a = dynamic_cast<A*>(b);
    if (a)
    {
       // now I can use all the stuff from A  
    }
    else
    {
       // that was something else, not descended from A
    }
}

忘了说：为了使工作动态转换，A 和 B 都应该有虚拟函数或至少有虚拟析构函数。否则就没有合法的方法来进行类型转换。

Answer 2

拥有大量从 A 和 B 派生的不相关的类是一个非常奇怪的设计。如果有什么东西使 A 和 B 始终“一起使用”，您可以合并它们或引入一个填充类 em> 仅从它们派生，然后仅从该类派生：

class Shim : A, B {};

class DerivedX : Shim {};

在后一种情况下，您只需使用 static_cast 首先从 A 或 B 向下转换code> 到 Shim*，然后 C++ 会隐式地将 Shim* 指针转换为另一个类。

Answer 3

如果您想在函数中使用 A 类和 B 类的功能，那么您应该修改该函数以接收 C 指针：

void foo(C* c);

一般来说，您认为“每个 B 也是 A”的假设是错误的。您可以创建从 B 接口派生的类，而不是从 A 类派生的类，这就是为什么编译器不会知道在您的特定情况下“每个 B 都是 A”。

Answer 4

扩展 Sharptooth 的答案（并将其作为答案输入，因为我无法将格式化代码放入注释中），您仍然可以使用垫片：

class Shim : public virtual A, public virtual B {};

然后：

class Derived1 : public Shim, public virtual A, public virtual B1
{
};

class Derived2 : public Shim, public virtual A, public virtual B2
{
};

B1 和 B2 必须实际上从 B 派生。

但我怀疑如果你总是需要同时实现 A 和
B，您应该创建一个包含两者的界面，或者通过
继承或将两者合并为一个类；您的 B1 和
B2 将从中继承。 （解决方案与
dynamic_cast 当然，是针对派生的情况
B 的类可能也可能不是从 A 派生的。）