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

Смысл виртуального наследования в том, чтобы разрешить совместное использование базовых классов. Вот проблема:

struct base { int member; virtual void method() {} };
struct derived0 : base { int d0; };
struct derived1 : base { int d1; };
struct join : derived0, derived1 {};
join j;
j.method();
j.member;
(base *)j;
dynamic_cast<base *>(j);

Последние 4 строки неоднозначны. Вы должны явно указать, хотите ли вы, чтобы база находилась внутри производного0 или база внутри производного1.

Если вы измените вторую и третью строку следующим образом, проблема исчезнет:

struct derived0 : virtual base { int d0; };
struct derived1 : virtual base { int d1; };

Ваш объект j теперь имеет только одну копию базы, а не две, поэтому последние 4 строки перестают быть двусмысленными.

Но подумайте, как это должно быть реализовано. Обычно в производном0 d0 идет сразу после m, а в производном1 d1 идет сразу после m. Но при виртуальном наследовании они оба имеют один и тот же m, поэтому вы не можете иметь сразу после него и d0, и d1. Так что вам понадобится какая-то форма дополнительной косвенности. Вот откуда берется дополнительный указатель.

Если вы хотите точно знать, что такое макет, это зависит от вашей целевой платформы и компилятора. Просто "gcc" недостаточно. Но для многих современных целей, отличных от Windows, ответ определяется через Itanium C++ ABI, который задокументирован по адресу http://mentorembedded.github.com/cxx-abi/abi.html#vtable.

Здесь есть две отдельные вещи, которые вызывают дополнительные накладные расходы.

Во-первых, наличие виртуальных функций в базовом классе увеличивает его размер на размер указателя (в данном случае 4 байта), поскольку ему необходимо хранить указатель на таблицу виртуальных методов:

normal inheritance with virtual functions:

0        4       8       12
|      base      |
| vfptr  |  i    |   j   |

Во-вторых, при виртуальном наследовании в derived требуется дополнительная информация, чтобы можно было определить местонахождение base. При обычном наследовании смещение между derived и base является константой времени компиляции (0 для одиночного наследования). В виртуальном наследовании смещение может зависеть от типа среды выполнения и фактической иерархии типов объекта. Реализации могут различаться, но, например, Visual C++ делает это примерно так:

virtual inheritance with virtual functions:

0        4         8        12        16
                   |      base        |
|  xxx   |   j     |  vfptr |    i    |

Где xxx — указатель на информационную запись некоторого типа, позволяющую определить смещение до base.

И, конечно же, возможно виртуальное наследование без виртуальных функций:

virtual inheritance without virtual functions:

0        4         8        12
                   |  base  |
|  xxx   |   j     |   i    |

Если у класса есть какая-либо виртуальная функция, объекты этого класса должны иметь vptr, то есть указатель на vtable, то есть виртуальную таблицу, из которой можно найти адрес правильной виртуальной функции. Вызываемая функция зависит от динамического типа объекта, который является наиболее производным классом, базовым подобъектом которого является объект.

Поскольку производный класс виртуально наследуется от базового класса, расположение базового класса относительно производного класса не является фиксированным, оно также зависит от динамического типа объекта. С gcc класс с виртуальными базовыми классами нуждается в vptr для поиска базовых классов (даже если виртуальной функции нет).

Кроме того, базовый класс содержит член данных, который расположен сразу после базового класса vptr. Схема памяти базового класса: { vptr, int }

Если базовому классу требуется vptr, производному от него классу также потребуется vptr, но часто повторно используется «первый» vptr подобъекта базового класса (этот базовый класс с повторно используемым vptr называется первичной базой). Однако в данном случае это невозможно, потому что производному классу нужен vptr не только для определения того, как вызывать виртуальную функцию, но и для того, чтобы определить, где находится виртуальная база. Производный класс не может найти свой виртуальный базовый класс без использования vptr; если виртуальный базовый класс использовался как первичный, производный класс должен был найти первичный базовый класс, чтобы прочитать vptr, и должен был прочитать vptr, чтобы найти первичный базовый элемент.

Таким образом, у производного не может быть первичной базы, и он вводит свой собственный vptr.

Макет подобъекта базового класса типа derived выглядит следующим образом: { vptr, int } с vptr, указывающим на виртуальную таблицу для производных, содержащую не только адреса виртуальных функций , но и относительное расположение всех его виртуальных базовых классов (здесь просто base), представленное как смещение.

Макет полного объекта типа derived выглядит следующим образом: { подобъект базового класса типа derived, base }

Таким образом, минимальный возможный размер derived составляет (2 int + 2 vptr) или 4 слова в обычных архитектурах ptr = int = word, или 16 байт в данном случае. (А Visual C++ создает большие объекты (когда задействованы виртуальные базовые классы), я полагаю, что derived будет иметь еще один указатель.)

Так что да, виртуальные функции имеют свою цену, и виртуальное наследование имеет свою цену. Затраты памяти на виртуальное наследование в этом случае составляют еще один указатель на объект.

В проектах со многими виртуальными базовыми классами затраты памяти на объект могут быть пропорциональны количеству виртуальных базовых классов или нет; нам нужно будет обсудить конкретные иерархии классов, чтобы оценить стоимость.

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

Что происходит, так это дополнительные накладные расходы, используемые для пометки класса как имеющего виртуальные члены или включающего виртуальное наследование. Сколько лишнего зависит от компилятора.

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

Возможно, дополнительные 4 байта необходимы для обозначения типа класса во время выполнения. Например:

class A {
 virtual int f() { return 2; }
}

class B : virtual public A {
 virtual int f() { return 3; }
}

int call_function( A *a) {
   // here we don't know what a really is (A or B)
   // because of this to call correct method
   // we need some runtime knowledge of type and storage space to put it in (extra 4 bytes).
   return a->f();
}

int main() {
   B b;
   A *a = (A*)&b;

   cout << call_function(a);
}

Дополнительный размер связан с указателем vtable/vtable, который «невидимо» добавляется к вашему классу, чтобы удерживать указатель функции-члена для определенного объекта этого класса или его потомка/предка.

Если это неясно, вам нужно больше читать о виртуальном наследовании в C++.