Где «виртуальное» ключевое слово необходимо в сложной иерархии множественного наследования?

Я придумал программу, которая может помочь вам в изучении тонкостей виртуальных баз. Она печатает иерархию классов под I в виде диграфа, подходящего для graphiviz ( http://www.graphviz.org/ ). Для каждого экземпляра есть счетчик, который также помогает понять порядок построения. Вот программа:

#include <stdio.h>
int counter=0; 



#define CONN2(N,X,Y)\
    int id; N() { id=counter++; }\
    void conn() \
    {\
        printf("%s_%d->%s_%d\n",#N,this->id,#X,((X*)this)->id); \
        printf("%s_%d->%s_%d\n",#N,this->id,#Y,((Y*)this)->id); \
        X::conn(); \
        Y::conn();\
    }
#define CONN1(N,X)\
    int id; N() { id=counter++; }\
    void conn() \
    {\
        printf("%s_%d->%s_%d\n",#N,this->id,#X,((X*)this)->id); \
        X::conn(); \
    }

struct A { int id; A() { id=counter++; } void conn() {} };
struct B : A { CONN1(B,A) };
struct C : A { CONN1(C,A)  };
struct D : B { CONN1(D,B) };
struct E : B,C { CONN2(E,B,C) };
struct F : C { CONN1(F,C) };
struct G : D,E { CONN2(G,D,E) };
struct H : E,F { CONN2(H,E,F) };
struct I : G,H { CONN2(I,G,H) };
int main()
{
    printf("digraph inh {\n");
    I i; 
    i.conn(); 
    printf("}\n");
}

Если я выполню это (g++ base.cc ; ./a.out >h.dot ; dot -Tpng -o o.png h.dot ; display o.png ), то получу типичное невиртуальное дерево базы:

Добавление достаточной виртуальности...

struct B : virtual A { CONN1(B,A) };
struct C : virtual A { CONN1(C,A)  };
struct D : virtual B { CONN1(D,B) };
struct E : virtual B, virtual C { CONN2(E,B,C) };
struct F : virtual C { CONN1(F,C) };
struct G : D, virtual E { CONN2(G,D,E) };
struct H : virtual E,F { CONN2(H,E,F) };
struct I : G,H { CONN2(I,G,H) };

... приводит к форме алмаза (посмотрите на цифры, чтобы узнать порядок построения!!)

Но если вы сделаете все базы виртуальными:

struct A { int id; A() { id=counter++; } void conn() {} };
struct B : virtual A { CONN1(B,A) };
struct C : virtual A { CONN1(C,A)  };
struct D : virtual B { CONN1(D,B) };
struct E : virtual B, virtual C { CONN2(E,B,C) };
struct F : virtual C { CONN1(F,C) };
struct G : virtual D, virtual E { CONN2(G,D,E) };
struct H : virtual E, virtual F { CONN2(H,E,F) };
struct I : virtual G,virtual H { CONN2(I,G,H) };

Вы получите алмаз с другим порядком инициализации:

Развлекайтесь!

Мое личное предложение - начать с B и C: виртуальный A, а затем продолжать добавлять, пока компилятор не перестанет жаловаться.

На самом деле, я бы сказал, что B и C: виртуальные A, G и H: виртуальные E, а E: виртуальные B и C. Все остальные связи наследования могут быть нормальным наследованием. Однако этому чудовищу потребовалось бы около шести десятилетий, чтобы совершить виртуальный звонок.

Отредактировано : я думал, что A был наиболее производным классом;)

@ Ответ Лютера действительно крутой, но вернемся к исходному вопросу:

Вам НЕОБХОДИМО использовать виртуальное наследование, когда наследование от любого класса, от которого в иерархии наследования наследуется хотя бы один другой класс (на диаграммах Лютера это означает, что по крайней мере две стрелки указывают на класс).

Здесь нет необходимости перед D , F , G и H , потому что только один класс является производным от них (и ни один не является производным от них). Я на данный момент).

Однако, если вы заранее не знаете, будет ли другой класс унаследован от вашего базового класса, вы можете добавить виртуальный в качестве меры предосторожности. Например, рекомендуется, чтобы класс Exception фактически унаследовал от std :: exception ни кем иным, как самим Страуструпом.

Как заметил Лютер, он изменяет порядок создания экземпляров (и имеет небольшое влияние на производительность), но я считаю, что любой дизайн, основанный на порядке создания, изначально был неправильным. И точно так же: у вас по-прежнему есть гарантии, что базовые классы инициализируются перед любым атрибутом производного класса и, следовательно, перед выполнением тела производного конструктора.

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

В вашем случае классы A , B , C и E должны становиться виртуальными базовыми классами каждый раз, когда вы наследуете от них в этой иерархии.

Классы D , F , G и H не должны становиться виртуальными базовыми классами.

Если вы хотите иметь только один "физический" экземпляр каждого типа для каждого экземпляра каждого типа (только один A, только один B и т.д.), вам просто придется использовать виртуальное наследование каждый раз, когда вы используете наследование.

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