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 la clase base en un puntero de la 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);  // É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 te 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

Aunque dynamic_cast es útil, su uso frecuente suele indicar un problema de diseño. Prefiere las funciones virtuales cuando sea posible, ya que permiten que el objeto gestione el comportamiento específico del tipo sin una comprobación explícita del tipo.

Desafío

Fácil

Construyamos un sistema de inspección de vehículos que use dynamic_cast para identificar e interactuar de forma segura con distintos tipos de vehículos. Crearás una jerarquía de vehículos en la que un inspector debe realizar comprobaciones específicas del 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 del sistema:
- Un miembro protegido std::string licensePlate
- Un constructor que inicializa la matrícula
- 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 automóvil
2. Matrícula del camión
3. Matrícula de la motocicleta
Crea un Car con 4 asientos, un Truck con una capacidad de 10.5 toneladas 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. Libera los objetos asignados dinámicamente cuando termines.

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 únicamente cuando el tipo real del objeto 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.

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: Crea un Car con 4 asientos
    // TODO: Crea un Truck con capacidad de 10.5 toneladas
    // TODO: Crea un Motorcycle con sidecar (true)

    // TODO: Almacena los tres en un array de punteros Vehicle*

    // TODO: Recorre el array y para cada vehículo:
    //   1. Imprime su descripción usando getDescription()
    //   2. Usa dynamic_cast para intentar convertir 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. If cast to Motorcycle* succeeds, call inspectHelmetStorage()
    //   6. Imprime una línea en blanco entre la inspección de cada vehículo

    // TODO: Libera los objetos asignados dinámicamente

    return 0;
}