encasillamiento con funciones virtuales

Question

En el siguiente código, PC == pA:

class A 
{ 
}; 

class B : public A 
{ 
public: 
    int i; 
}; 

class C : public B 
{ 
public: 
    char c; 
}; 

int main() 
{ 
    C* pC = new C; 
    A* pA = (A*)pC; 

    return 0; 
} 

Pero cuando agrego una función virtual pura a B y ponerlo en práctica en C, pA = pC:

class A 
{ 
}; 

class B : public A 
{ 
public: 
    int i; 
    virtual void Func() = 0; 
}; 

class C : public B 
{ 
public: 
    char c; 
    void Func() {} 
}; 

int main() 
{ 
    C* pC = new C; 
    A* pA = (A*)pC; 

    return 0; 
} 

¿Por qué pA no es igual a pC en este caso? ¿No señalan ambos el mismo objeto "C" en la memoria?

Answer 1

Está viendo un valor diferente para su puntero porque la nueva función virtual está causando la inyección de un puntero vtable en su objeto. VC++ pone el puntero vtable al principio del objeto (que es típico, pero puramente un detalle interno).

Agreguemos un nuevo campo a A para que sea más fácil de explicar.

class A { 
public: 
    int a; 
}; 
// other classes unchanged 

Ahora, en la memoria, su pA y A ser algo como esto:

pA --> | a  |   0x0000004 

Una vez que añadir B y C en la mezcla, se termina con esto:

pC --> | vtable |   0x0000000 
pA --> | a  |   0x0000004 
     | i  |   0x0000008 
     | c  |   0x000000C 

Como puede ver, pA apunta a los datos después de el vtable, porque no sabe nada sobre t él vtable o cómo usarlo, o incluso que está allí. pC sabe sobre el vtable, por lo que apunta directamente a la tabla, lo que simplifica su uso.

Answer 2

Un puntero a un objeto es convertible a un puntero al objeto base y viceversa, pero la conversión no tiene por qué ser trivial. Es completamente posible, y a menudo necesario, que el puntero base tenga un valor diferente que el puntero derivado. Es por eso que tiene un sistema de tipo fuerte y conversiones. Si todos los punteros fueran iguales, tampoco lo necesitaría.

Answer 3

Aquí están mis suposiciones, basadas en la pregunta.

1) Tienes un caso en el que lanzas de una C a una A y obtienes el comportamiento esperado.
2) Agregaste una función virtual, y ese reparto ya no funciona (dado que ya no puedes extraer datos de A directamente después del lanzamiento a A, obtienes datos que no tienen sentido para ti).

Si estas suposiciones son ciertas, la dificultad que experimenta es la inserción de la tabla virtual en B. Esto significa que los datos en la clase ya no se alinean perfectamente con los datos en la clase base (como en la clase bytes agregados, la tabla virtual, que están ocultos para usted). Una prueba divertida sería verificar sizeof para observar el crecimiento de bytes desconocidos.

Para resolver esto, no debe lanzar directamente de A a C a los datos de cosecha. Debería agregar una función getter que está en A y heredada por B y C.

Dada su actualización en los comentarios, creo que debería leer this, explica las tablas virtuales y el diseño de la memoria, y de qué depende el compilador . Ese enlace explica, con más detalle, lo que expliqué anteriormente, pero da ejemplos de que los punteros son valores diferentes. Realmente, tenía POR QUÉ me estabas preguntando mal, pero parece que la información sigue siendo la que querías. El elenco de C a A tiene en cuenta la tabla virtual en este punto (nota C-8 es 4, que en un sistema de 32 bits sería el tamaño de la dirección necesaria para la tabla virtual, creo).