C++ 多重虚拟继承与 COM答案

【问题标题】：C++ Multiple Virtual Inheritance vs. COMC++ 多重虚拟继承与 COM
【发布时间】：2010-09-22 21:51:31
【问题描述】：

网络上充斥着对"dreaded diamond problem"的解释。 StackOverflow 也是如此。我想我理解这一点，但我无法将这些知识转化为理解相似但不同的东西。

我的问题一开始是一个纯 C++ 问题，但答案很可能会扩展到 MS-COM 细节。一般问题的问题是：

class Base { /* pure virtual stuff */ };
class Der1 : Base /* Non-virtual! */ { /* pure virtual stuff */ };
class Der2 : Base /* Non-virtual! */ { /* pure virtual stuff */ };
class Join : virtual Der1, virtual Der2 { /* implementation stuff */ };
class Join2 : Join { /* more implementation stuff + overides */ };

这不是经典的钻石解决方案。 “虚拟”在这里究竟做了什么？

我真正的问题是试图理解 discussion over at our friends' place at CodeProject. 它涉及一个自定义类，用于为 Flash 播放器创建透明容器。

我想我会试试这个地方玩。事实证明，以下声明会使您的应用程序崩溃，使用版本 10 的 Flash 播放器。

class FlashContainerWnd:   virtual public IOleClientSite,
                           virtual public IOleInPlaceSiteWindowless,
                           virtual public IOleInPlaceFrame,
                           virtual public IStorage

调试表明，当输入来自不同调用者的函数实现（QueryInterface 等）时，对于不同的调用，我会得到不同的“this”指针值。但是删除“虚拟”就可以了！没有崩溃，同样的“this”指针。

我想清楚地了解到底发生了什么。非常感谢。

干杯亚当

【问题讨论】：

我不擅长虚拟继承。但是您的应用程序是否包含从 IOle 或 IStorage 内容转换为 FlashContainerWnd 的转换？

标签： c++ com multiple-inheritance virtual-inheritance

【解决方案1】：

第一个例子中的虚拟继承没有做任何事情。我敢打赌，如果它们被删除，它们会编译成相同的代码。

虚拟继承的类只是标记编译器它应该合并更高版本的Der1 或Der2。由于每一个都只出现在继承树中，因此没有做任何事情。 virtuals 对Base 没有影响。

auto p = new Join2;
static_cast<Base*>(static_cast<Der1*>(p)) !=
      static_cast<Base*>(static_cast<Der2*>(p))

虚拟继承仅影响下一个继承的类，并且仅适用于已被定义为虚拟的实例。这与您的预期相反，但它是对类编译方式的限制。

class A {};
class B : virtual public A {};
class C : virtual public A {};
class D : public A {};
class E : virtual public A, public B, public C, public D {};
class F : public A, public B, public C, public D {};

F::A != F::B::A or F::C::A or F::D::A
F::B::A == F::C::A
F::D::A != F::B::A or F::C::A or F::A

E::B::A == E::C::A == E::A
E::D::A != E::B::A or E::C::A or E::D::A

必须在 C 和 B 中将 A 标记为 virtual 而不是 E 或 F 的原因之一是 C 和 B 需要知道不要调用 A 的构造函数。通常他们会初始化他们的每个副本。当他们参与钻石继承时，他们不会。但是你不能重新编译 B 和 C 以不构造 A。这意味着 C 和 B 必须提前知道创建不调用 A 的构造函数的构造函数代码。

【讨论】：

我不确定您所说的“已被虚拟化的实例”是什么意思。如果您的意思是 subsequnet 虚拟继承，那么不幸的是，我的现实世界问题证明您的答案是错误的。因为我只有一个级别的虚拟。与虚拟：崩溃。没有虚拟：好。

【解决方案2】：

我认为您的 COM 示例的问题在于，通过添加 virtual 关键字，您是在说所有 IOle* 接口共享一个通用的 IUnknown 实现。为了实现这一点，编译器必须创建多个 v-table，因此根据派生类的不同，您可以使用不同的 'this' 值。

COM 要求，当您对 IUnknown 对象调用 IQueryInterface 时，该对象公开的 ALL 接口返回 same IUnknown ...此实现显然会破坏。

如果没有虚拟继承，每个 IOle* 名义上都有自己的 IUnknown 实现。但是，由于 IUnknown 是一个抽象类，编译器没有任何存储空间，并且所有 IUnknown 实现都来自 FlashContainerWnd，因此只有一个实现。

（好吧，所以最后一点听起来很弱......也许对语言规则掌握更好的人可以更清楚地解释它）

【讨论】：

是的，我认为你是对的。你得到 IUnknown 然后使用 QueryInterface 得到你想要的接口。您不会以通常的 C++ 方式强制转换 COM 对象。
谢谢，如果我理解你的回答正确，我应该使用“虚拟”，但事实是我必须删除它才能停止崩溃。所以我无法理解这如何回答我的问题。

【解决方案3】：

现在有点过时了，但我遇到过的关于 C++ 内部的最佳参考是 Lippman 的 Inside The C++ Object Model。确切的实现细节可能与编译器的输出不匹配，但它提供的理解非常有价值。

在第 96 页左右，有一个关于虚拟继承的解释，它专门解决了菱形问题。

我会让您阅读详细信息，但基本上虚拟继承的使用需要在虚拟表中查找才能找到基类。这不是普通继承的情况，基类的位置可以在编译时计算出来。

（上次我采取了简单的方法，只是推荐了一本书来回答堆栈溢出问题，我得到了相当多的投票，所以让我们看看这种情况是否会再次发生......:)

【讨论】：

谢谢，但如果您仔细阅读我的问题，这不是钻石问题。

【解决方案4】：

我想我会试试你的例子。我想出了：

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

class Base
{
public:
  virtual void say_hi(const char* s)=0;
};

class Der1 : public Base
{
public:
  virtual void d1()=0;
};

class Der2 : public Base
{
public:
  virtual void d2()=0;
};

class Join : virtual public Der1, virtual public Der2
             // class Join : public Der1, public Der2
{
public:
  virtual void say_hi(const char* s);
  virtual void d1();
  virtual void d2();
};

class Join2 : public Join
{
  virtual void d1();
};

void Join::say_hi(const char* s)
{
  printf("Hi %s (%p)\n", s, this);
}

void Join::d1()
{}

void Join::d2()
{}

void Join2::d1()
{
}

int _tmain(int argc, _TCHAR* argv[])
{
  Join2* j2 = new Join2();
  Join* j = dynamic_cast<Join*>(j2);
  Der1* d1 = dynamic_cast<Der1*>(j2);
  Der2* d2 = dynamic_cast<Der2*>(j2);
  Base* b1 = dynamic_cast<Base*>(d1);
  Base* b2 = dynamic_cast<Base*>(d2);

  printf("j2: %p\n", j2);
  printf("j:  %p\n", j);
  printf("d1: %p\n", d1);
  printf("d2: %p\n", d2);
  printf("b1: %p\n", b1);
  printf("b2: %p\n", b2);

  j2->say_hi("j2");
  j->say_hi(" j");
  d1->say_hi("d1");
  d2->say_hi("d2");
  b1->say_hi("b1");
  b2->say_hi("b2");

  return 0;
}

它产生以下输出：

j2: 00376C10
j:  00376C10
d1: 00376C14
d2: 00376C18
b1: 00376C14
b2: 00376C18
Hi j2 (00376C10)
Hi  j (00376C10)
Hi d1 (00376C10)
Hi d2 (00376C10)
Hi b1 (00376C10)
Hi b2 (00376C10)

因此，当将 Join2 强制转换为其基类时，您可能会得到不同的指针，但传递给 say_hi() 的 this 指针始终是相同的，与预期的差不多。

因此，基本上，我无法重现您的问题，因此很难回答您的真实问题。

关于 wat “virtual” 的作用，我发现 wikipedia 上的文章很有启发性，尽管那似乎也关注钻石问题

【讨论】：

【解决方案5】：

正如 Caspin 所说，您的第一个示例实际上并没有做任何有用的事情。然而，它会做的是添加一个 vpointer 来告诉派生类在哪里可以找到它所继承的类。

这修复了您现在可能创建的任何菱形（您没有创建），但是由于类结构现在不再是静态的，因此您不能再对其使用 static_cast。我对所涉及的 API 不熟悉，但 Rob Walker 所说的 IUnkown 可能与此有关。

简而言之，当您需要 自己的 基类时，应该使用正常继承，它不应该与“兄弟”类共享：（a 是一个容器，b,c,d 是部分每个都有一个容器，e 组合了这些部分（不好的例子，为什么不使用组合？））

a  a  a
|  |  |
b  c  d <-- b, c and d inherit a normally
 \ | /
   e

当你的基类应该与他们共享时，虚拟继承是适用的。（a是车辆，b，c，d是车辆的不同专业，e结合了这些）

   a
 / | \
b  c  d <-- b, c and d inherit a virtually
 \ | /
   d

【讨论】：