Понимание размера виртуального производного класса

Результат может отличаться в зависимости от используемого компилятора и архитектуры системы. Например, 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++, за исключением того факта, что компилятору разрешено добавлять отступы, и я фактически не исследовал какой-либо ассемблерный код.

Если скомпилировать в GCC на архитектуре x64, структура может выглядеть так:

+-----------------------------------------------------------------------------------------------------+
| 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 байтам, а все остальные структуры выравниваются по 8 байтам при использовании компилятора GCC.

Я предполагаю, что ваш компьютер имеет архитектуру x64. Это означает, что длина указателя должна быть не менее 8 байт, а поскольку vptr существует в B1 и B2, вся структура выравнивается по 8 байтам. Из-за этого компилятору необходимо добавить отступы к обеим структурам, чтобы сохранить sizeof(B1) % alignof(B1) == 0 (или, проще говоря, чтобы структура оставалась выровненной).

Не очень важно знать, как именно C размещается и дополняется, поскольку это определяется реализацией и будет различаться на разных платформах. Но есть одна специфическая деталь...

Базовый класс A, будучи фактически унаследованным, извлекается на вершину иерархии. Так что это часть B1 только до тех пор, пока B1 используется сам по себе. Когда он наследуется внутри C, A больше не является его частью.

Это означает, что мы не можем полагаться на sizeof(B1) или sizeof(B2), так как сначала нужно вычесть из них sizeof(A). Но удаление 4 байтов из B1 не уменьшит его размер с 16 до 12, поскольку он должен быть выровнен и дополнен до 8 байтов (при условии, что он 64-битный) из-за vbptr.

Таким образом, мы получаем 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;
}

Распечатки:

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

Теперь более понятно, что sizeof(C) ‹ sizeof(B1) + sizeof(B2).

Чтобы узнать больше, вы можете поиграть со смещениями, чтобы увидеть, как именно расположено C.