了解虚拟派生类的大小 更新

如何解决了解虚拟派生类的大小 更新

#include <iostream>
using namespace std;
class A {
  int a;
};
class B1 : virtual public A {
  int b1;
};
class B2 : virtual public A {
  int b2;
};
class C : public B1,public B2 {
  int c;
};

int main() {
  A obj1; B1 obj2; B2 obj3; C obj4;
  cout << sizeof(obj1) << endl;
  cout << sizeof(obj2) << endl;
  cout << sizeof(obj3) << endl;
  cout << sizeof(obj4) << endl;
  return 0;
}

输出：

4
16
16
40

在上面的c++程序中， A 的大小是 4，因为它只有一个 int B1 的大小为 16，因为 (int+ int + 虚拟指针) 与 B2 相同

但是C的大小怎么是40？？？

解决方法

结果可能因您使用的编译器和系统架构而异。例如，msvc 19.28 x64 给出了这个不言自明的结果（使用选项 /d1reportAllClassLayout 得到它）：

class C size(44):
    +---
 0  | +--- (base class B1)
 0  | | {vbptr}
 8  | | b1
    | | <alignment member> (size=4)
    | | <alignment member> (size=4)
    | +---
16  | +--- (base class B2)
16  | | {vbptr}
24  | | b2
    | | <alignment member> (size=4)
    | | <alignment member> (size=4)
    | +---
32  | c
    | <alignment member> (size=4)
    +---
    +--- (virtual base A)
40  | a
    +---

但是对于 msvc 19.28 x86，结果是：

class C size(24):
    +---
 0  | +--- (base class B1)
 0  | | {vbptr}
 4  | | b1
    | +---
 8  | +--- (base class B2)
 8  | | {vbptr}
12  | | b2
    | +---
16  | c
    +---
    +--- (virtual base A)
20  | a
    +---

更新

需要注意的是，上面的类布局清楚地展示了虚继承的特点，其中只有一个基类实例（A）的副本被孙子派生类（C）继承.如果 A::a 数据成员是公共的，我们可以在类 C 的成员函数中使用以下语句：

void C::foo() {
    B2::a = 1;
    B1::a = 2;
    std::cout << B2::a << " " << B1::a << " " << A::a; // Output: 2 2 2
}

但是如果你不使用虚拟继承（而只是公共），那么类 C 的布局将是这样的：

class C size(20):
    +---
 0  | +--- (base class B1)
 0  | | +--- (base class A)
 0  | | | a
    | | +---
 4  | | b1
    | +---
 8  | +--- (base class B2)
 8  | | +--- (base class A)
 8  | | | a
    | | +---
12  | | b2
    | +---
16  | c
    +---

我们将拥有基类 A 的成员变量的两个副本

void C::foo() {
    B2::a = 1;
    B1::a = 2;
    std::cout << B2::a << " " << B1::a; // Output: 1 2. `A::a` ambiguity error
}

,

免责声明：除了允许编译器添加填充这一事实外，C++ 标准均未指定这些内容，而且我还没有实际检查任何汇编代码。

如果在 x64 架构的 GCC 中编译，结构可能如下所示：

+-----------------------------------------------------------------------------------------------------+
| C                                                                                                   |
| +------------------------------------+ +------------------------------------+          +----------+ |
| | B1 (16)                            | | B2 (16)                            |          | A(4)     | |
| | +--------------+ +------+ +------+ | | +--------------+ +------+ +------+ | +------+ | +------+ | |
| | |  vptr (8)    | | b1(4)| |pad(4)| | | |  vptr (8)    | | b2(4)| |pad(4)| | | c(4) | | | a(4) | | |
| | +--------------+ +------+ +------+ | | +--------------+ +------+ +------+ | +------+ | +------+ | |
| +------------------------------------+ +------------------------------------+          +----------+ |
+-----------------------------------------------------------------------------------------------------+

检查每个结构（https://wandbox.org/permlink/a4l99p6JwTrSdWx1）的对齐方式，我们看到A对齐到4个字节，使用GCC编译器时所有剩余的结构都对齐到8个字节。

我假设您的计算机采用 x64 架构。这意味着指针必须至少有 8 个字节长，并且因为 vptr 存在于 B1 和 B2 中，所以整个结构对齐到 8 个字节。因此，编译器需要为这两个结构添加填充，以保持 sizeof(B1) % alignof(B1) == 0（或简单地说以保持结构对齐）。

,

了解 C 的确切布局和填充方式并不是很重要，因为这是实现定义的，并且会因平台而异。但有一个具体细节...

基类 A 被虚拟继承，被提取到层次结构的顶部。因此，只要 B1 被“单独使用”，它就是 B1 的一部分。当它在 C 内部进一步继承时，A 不再是它的一部分。

这意味着我们不能依赖 sizeof(B1) 或 sizeof(B2)，因为我们必须先从它们中减去 sizeof(A)。但是从 B1 中删除 4 个字节不会将其大小从 16 减少到 12，因为由于 vbptr，它必须对齐并填充到 8 个字节（假设为 64 位）。

所以我们最终得到 sizeof(B1 less A)+sizeof(B2 less A)+sizeof(A)+sizeof(C::c) = 16+16+4+4 = 40。

如果我们将 A 放大，我们可以获得一些时髦的输出：

#include <iostream>
using namespace std;
class A {
  int a1,a2,a3,a4,a5;
};
class B1 : virtual public A {
  int b1;
};
class B2 : virtual public A {
  int b2;
};
class C : public B1,public B2 {
  int c;
};

int main() {
  A obj1; B1 obj2; B2 obj3; C obj4;
  cout << "sizeof(A)  = " << sizeof(obj1) << endl;
  cout << "sizeof(B1) = " << sizeof(obj2) << endl;
  cout << "sizeof(B2) = " << sizeof(obj3) << endl;
  cout << "sizeof(C)  = " << sizeof(obj4) << endl;
  return 0;
}

Prints：

sizeof(A)  = 20
sizeof(B1) = 32
sizeof(B2) = 32
sizeof(C)  = 56

现在更清楚的是 sizeof(C) sizeof(B1) + sizeof(B2)。

要了解更多信息，您可以play with offsets查看C的确切布局。