Dynamic Casting y RTTI

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 62 de 104.

A veces, al trabajar con polimorfismo, necesitas determinar el tipo real de un objeto en tiempo de ejecución o convertir de forma segura un puntero de clase base a un puntero de clase derivada. C++ proporciona RTTI (Información de Tipos en Tiempo de Ejecución) y dynamic_cast para estas situaciones.

dynamic_cast convierte de forma segura punteros o referencias dentro de una jerarquía de herencia. A diferencia de static_cast, realiza una comprobación en tiempo de ejecución y devuelve nullptr si la conversión no es válida:

class Animal {
public:
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

class Cat : public Animal {};

Animal* animal = new Dog();
Dog* dog = dynamic_cast<Dog*>(animal);  // Tiene éxito: devuelve un puntero válido

if (dog) {
    dog->bark();  // Es seguro llamar al método específico de Dog
}

Cat* cat = dynamic_cast<Cat*>(animal);  // Falla: devuelve nullptr

Importante: dynamic_cast solo funciona con tipos polimórficos (clases con al menos una función virtual). El operador typeid permite consultar el tipo real de un objeto:

#include <typeinfo>

Animal* pet = new Dog();
std::cout << typeid(*pet).name() << std::endl;  // Muestra información de tipo para Dog

Si bien dynamic_cast es útil, su uso frecuente a menudo indica un problema de diseño. Prefiera las funciones virtuales cuando sea posible, ya que permiten que el objeto maneje el comportamiento específico del tipo sin una comprobación de tipo explícita.

Desafío

Fácil

Vamos a construir un sistema de inspección de vehículos que utiliza dynamic_cast para identificar e interactuar de forma segura con diferentes tipos de vehículos. Crearás una jerarquía de vehículos donde un inspector necesita realizar comprobaciones específicas de tipo que solo ciertos vehículos admiten.

Organizarás tu código en tres archivos:

Vehicle.h: Define una clase base Vehicle que representa cualquier vehículo en el sistema:
- Un miembro protegido std::string licensePlate
- Un constructor que inicializa la matrícula (license plate)
- Un método virtual getDescription() que devuelve "Vehicle: <licensePlate>"
- Un destructor virtual
Vehicles.h: Define tres tipos de vehículos derivados:
Car:
- Un miembro privado int seatCount
- Un constructor que recibe la matrícula y el número de asientos
- Sobrescribe getDescription() para devolver "Car: <licensePlate>"
- Un método inspectSeatbelts() que imprime: Inspecting <seatCount> seatbelts in <licensePlate>
Truck:
- Un miembro privado double cargoCapacity (en toneladas)
- Un constructor que recibe la matrícula y la capacidad de carga
- Sobrescribe getDescription() para devolver "Truck: <licensePlate>"
- Un método inspectCargo() que imprime: Inspecting cargo area (<cargoCapacity> tons) in <licensePlate>
Motorcycle:
- Un miembro privado bool hasSidecar
- Un constructor que recibe la matrícula y el estado del sidecar
- Sobrescribe getDescription() para devolver "Motorcycle: <licensePlate>"
- Un método inspectHelmetStorage() que imprime: Inspecting helmet storage in <licensePlate> si tiene sidecar, o No helmet storage in <licensePlate> si no lo tiene
main.cpp: Lee tres entradas (cada una en una línea separada):
1. Matrícula del coche (Car)
2. Matrícula del camión (Truck)
3. Matrícula de la moto (Motorcycle)
Crea un Car con 4 asientos, un Truck con 10.5 toneladas de capacidad y una Motorcycle con sidecar. Almacena los tres en un arreglo de punteros Vehicle*.

Recorre el arreglo y para cada vehículo:
1. Imprime su descripción usando getDescription()
2. Usa dynamic_cast para intentar convertirlo a cada tipo derivado
3. Si la conversión a Car* tiene éxito, llama a inspectSeatbelts()
4. Si la conversión a Truck* tiene éxito, llama a inspectCargo()
5. Si la conversión a Motorcycle* tiene éxito, llama a inspectHelmetStorage()
Imprime una línea en blanco entre la inspección de cada vehículo. Limpia tus objetos asignados dinámicamente cuando hayas terminado.

Por ejemplo, con las entradas ABC-123, TRK-456 y MTR-789:

Car: ABC-123
Inspecting 4 seatbelts in ABC-123

Truck: TRK-456
Inspecting cargo area (10.5 tons) in TRK-456

Motorcycle: MTR-789
Inspecting helmet storage in MTR-789

Observa cómo dynamic_cast devuelve un puntero válido solo cuando el tipo de objeto real coincide con el tipo de destino. Para cada vehículo, solo una de las tres conversiones tendrá éxito, lo que te permite llamar de forma segura al método de inspección específico del tipo. Este es el poder de RTTI: determinar el tipo real en tiempo de ejecución y actuar en consecuencia.

Hoja de referencia

C++ proporciona RTTI (Runtime Type Information) y dynamic_cast para determinar el tipo real de un objeto en tiempo de ejecución y convertir punteros de forma segura dentro de una jerarquía de herencia.

dynamic_cast realiza una comprobación en tiempo de ejecución y devuelve nullptr si la conversión no es válida:

class Animal {
public:
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

Animal* animal = new Dog();
Dog* dog = dynamic_cast<Dog*>(animal);  // Succeeds: returns valid pointer

if (dog) {
    dog->bark();  // Safe to call Dog-specific method
}

Cat* cat = dynamic_cast<Cat*>(animal);  // Fails: returns nullptr

Importante: dynamic_cast solo funciona con tipos polimórficos (clases con al menos una función virtual).

El operador typeid consulta el tipo real de un objeto:

#include <typeinfo>

Animal* pet = new Dog();
std::cout << typeid(*pet).name() << std::endl;  // Outputs type info for Dog

Aunque es útil, el uso frecuente de dynamic_cast a menudo indica un problema de diseño. Prefiera las funciones virtuales cuando sea posible.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Vehicle.h"
#include "Vehicles.h"

using namespace std;

int main() {
    // Leer entradas
    string carPlate, truckPlate, motorcyclePlate;
    cin >> carPlate;
    cin >> truckPlate;
    cin >> motorcyclePlate;

    // TODO: Crear un Car con 4 asientos
    // TODO: Crear un Truck con 10.5 toneladas de capacidad
    // TODO: Crear una Motorcycle con un sidecar (true)

    // TODO: Almacenar los tres en un arreglo de punteros Vehicle*

    // TODO: Recorrer el arreglo y para cada vehículo:
    //   1. Imprimir su descripción usando getDescription()
    //   2. Usar dynamic_cast para intentar realizar el casting a cada tipo derivado
    //   3. Si el casting a Car* tiene éxito, llamar a inspectSeatbelts()
    //   4. Si el casting a Truck* tiene éxito, llamar a inspectCargo()
    //   5. Si el casting a Motorcycle* tiene éxito, llamar a inspectHelmetStorage()
    //   6. Imprimir una línea en blanco entre la inspección de cada vehículo

    // TODO: Limpiar los objetos asignados dinámicamente

    return 0;
}