Para poder hacer un cast a una subclase y que el cast sea correcto, la instancia afectada tiene que ser, necesariamente, de la subclase.

Me explico:

Class A
{ };
 
Class B : public A
{ };
 
int main ( ... )
{
  A* puntero1 = new A( );
  A* puntero2 = new B( );
 
  // este caso retornará 0 porque puntero1 no es de la subclase B
  B* clase_b1 = dynamic_cast< B* >( puntero1 );
 
  // este caso retornará un puntero válido
  B* clase_b2 = dynamic_cast< B* >( puntero2 );
}

Luego, dado que para que el cast funcione correctamente, la instancia original ha de ser de la subclase ( o de una subclase de la subclase ), necesariamente has tenido que crear una instancia de la subclase y, al hacer esa creación, se han tenido que inicializar necesariamente todos los miembros de la clase.

Si esto no es así es porque se te ha olvidado inicializar algo en el constructor.

dynamic_cast hace chequeos que verifican que, efectivamente, se puede hacer el cast a la clase destino. Esto solo es posible cuando la instancia apuntada es de la clase destino o de alguna clase hija... en caso contrario, el cast retornará un puntero nulo.

static_cast símplemente comprueba que el cast (a pelo) es válido. Es un chequeo muucho más sencillo que el dinámico y, por ello, más propenso a errores... por ejemplo que te deje hacer lo que estabas comentando.

Está claro que si tu tienes una superclase A... creas una instancia de esta clase y luego intentas hacer un cast a su subclase B... los miembros de esta subclase no pueden estar bien. En primer lugar porque en c++, a diferencia de en java, los miembros no se inicializan por defecto.

El constructor de A sólo sabe inicializar la parte que es propia de A... pero no sabe nada de la parte de B... luego esa parte siempre va a quedar con valores aleatorios.

Tu piensa que en el fondo, una clase no deja de ser x bytes en memoria y una serie de funciones que hacen uso de posiciones específicas de esa memoria... el concepto de clase solo tiene sentido para tí... la máquina no entiende de eso.

Efectivamente no se puede. Los constructores son llamados únicamente al crear la clase... una vez que ya está creada los constructores no son invocados de nuevo. Además, tu piensa que las subclases, como norma general, necesitan más memoria que las superclases... y la memoria ha de ser secuencial. Una vez ya has hecho una reserva de memoria no puedes garantizar que una nueva reserva se realice inmediatamente después... luego no podrías crear correctamente la nueva clase.


A ver, voy a intentar explicarlo con algo físico... para que sea más gráfico.

Tu imagínate que tienes la superclase Animal... y de ella heredan las clases Gato y Perro.

Si tu ( imagínate que eres una especie de dios ), creas un Gato... a ese gato lo puedes identificar como gato o como animal... pero nunca llegará a ser un perro ( tus poderes no dan para tanto ).

Si en vez de un gato creas un perro pasará exactamente lo mismo, el perro podrá ser tratado como un perro o como un animal, pero nunca como un gato.

El polimorfismo lo que te permite es tener punteros genéricos ( de tipo superclase ), que en realidad representen a entidades heredadas... pero este mecanismo no permite experimentos de mutación genética que permitan convertir un perro en un gato.

Si tu intentas llevar a cabo esta aberración de la naturaleza te pasará lo siguiente:

class Animal
{
};
 
class Perro: public Animal
{
};
 
class Gato : public Animal
{
};
 
void main( )
{
  Animal* gato = new Gato( );
  Animal* perro = new Perro( );
 
  Gato* gato1 = dynamic_cast< Gato* >( gato ); // ok
  Gato* gato2 = static_cast< Gato* >( gato ); // ok pero menos seguro
 
  Perro* perro1 = dynamic_cast< Perro* >( perro ); // ok
  Perro* perro2 = static_cast< Perro* >( perro ); // ok pero menos seguro
 
  Gato* aberracion1 = dynamic_cast< Gato* >( perro ); // devuelve 0.
  Gato* aberracion2 = static_cast< Gato* >( perro ); // funciona pero la aplicación va a dar resultados incorrectos o casques.
 
  Perro* aberracion3 = dynamic_cast< Perro* >( gato); // devuelve 0.
  Perro* aberracion4 = static_cast< Perro* >( gato); // te funciona pero la aplicación va a dar resultados incorrectos o casques.
}