¿Dónde es necesaria la palabra clave "virtual" en una compleja jerarquía de herencia múltiple?

Question

Entiendo los conceptos básicos de la herencia virtual de C++. Sin embargo, estoy confundido sobre dónde exactamente necesito usar la palabra clave virtual con una jerarquía de clase compleja. Por ejemplo, supongamos que tengo las siguientes clases:

  A 
     /\ 
      B C 
     /\/\ 
     D E F 
     \/\/
      G H 
      \/
      I 

Si quiero asegurar que ninguna de las clases aparecer más de una vez en cualquiera de las subclases, que deben ser marcados virtual clases base? ¿Todos ellos? ¿O es suficiente usarlo solo en aquellas clases que se derivan directamente de una clase que de otro modo podría tener múltiples instancias (es decir, B, C, D, E y F, y G y H (pero solo con la clase base E, no con las clases base D y F))?

Answer 1

Tiene que especificar la herencia virtual al heredar de cualquiera de las clases A, B, C y E (que se encuentran en la parte superior de un diamante).

class A; 
class B: virtual A; 
class C: virtual A; 
class D: virtual B; 
class E: virtual B, virtual C; 
class F: virtual C; 
class G:   D, virtual E; 
class H: virtual E,   F; 
class I:   G,   H; 

Answer 2

Mi sugerencia personal sería comenzar en B y C: virtual A, y luego seguir agregando hasta que el compilador deje de quejarse.

En realidad, diría que B y C: virtual A, G y H: virtual E, y E: virtual B y C. Todos los otros enlaces de herencia pueden ser herencia normal. Sin embargo, esta monstruosidad tomaría como seis décadas para hacer una llamada virtual.

Answer 3

Si usted quiere tener sólo una instancia "física" de cada tipo para cada instancia de cada tipo (sólo una A, B único, etc.) Sólo tendrá que usar la herencia virtual cada vez que se usar herencia.

Si desea instancias separadas de uno de los tipos, use la herencia normal.

Answer 4

Jugué un programa en conjunto que podría ayudarte a estudiar las complejidades de las bases virtuales. Imprime la jerarquía de clases bajo I como un dígrafo adecuado para graphiviz (http://www.graphviz.org/). Hay un contador para cada instancia que también te ayuda a comprender la orden de construcción. Aquí está la Programm:

#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"); 
} 

Si funciono esto (g++ base.cc ; ./a.out >h.dot ; dot -Tpng -o o.png h.dot ; display o.png), me sale el típico árbol de base no virtual: alt text http://i34.tinypic.com/2ns6pt4.png

añadiendo suficiente virtualidad ...

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) }; 

.. resultados en la forma del diamante (mira los números para aprender la orden de construcción !!)

alt text http://i33.tinypic.com/xpa2l5.png

Pero si haces todas las bases virtuales:

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) }; 

obtienes un diamante con una orden de inicialización diferente:

alt text http://i33.tinypic.com/110dlj8.png

Diviértete!

Answer 5

Si desea asegurarse de que un objeto de la clase superior en la jerarquía (I en su caso) contiene exactamente un subobjeto de cada clase padre, usted tiene que encontrar todas las clases en la jerarquía que tienen más de una superclase y hacer estas clases virtual bases de sus superclases. Eso es.

En sus clases de casos A, B, C y E tiene que convertirse en clases base virtuales cada vez que se hereda de ellos en esta jerarquía.

Las clases D, F, G y H no tienen que convertirse en clases base virtuales.

Answer 6

Editado: pensé que una era la clase más derivada;)

@ respuesta de Lutero realmente genial, pero de vuelta a la pregunta original:

Necesita utilizar virtual herencia al heredar de cualquier clase de la cual al menos otra clase hereda en la jerarquía de herencia (en los diagramas de Luther significa que al menos dos flechas apuntan a la clase).

Aquí es innecesario antes D, F, G y H porque sólo una clase se deriva de ellos (y ninguno se deriva de I por el momento).

Sin embargo, si no sabe de antemano si otra clase heredará o no de su clase base, puede agregar virtual como medida de precaución. Por ejemplo, se recomienda que una clase Exception herede virtualmente desde std::exception nada menos que con el propio Stroustrup.

Como ha señalado Luther, modifica la orden de creación de instancias (y tiene un ligero efecto en las actuaciones), pero yo consideraría que cualquier diseño que dependa de la orden de construcción es incorrecto para empezar. Y solo como precisión: usted todavía tiene las garantías de que las clases base se inicializan antes que cualquier atributo de la clase derivada, y por lo tanto antes de la ejecución del cuerpo constructor derivado.

Answer 7

Lo que hay que tener en cuenta es que C++ guarda una tabla de la herencia. Cuanto más agregue clases virtuales, mayor será el tiempo de compilación (vinculación) y el más pesado será el tiempo de ejecución.

En general, si se puede evitar la clase virtual, puede reemplazarla por algunas plantillas o tratar de desacoplar de alguna manera.