Conversión dinámica 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 el polimorfismo, necesitas determinar el tipo real de un objeto durante la ejecución o convertir de forma segura un puntero a una clase base en un puntero a una 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);  // Se realiza correctamente: 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 de 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 comprobaciones explícitas de 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 admiten ciertos vehículos.

Organizarás el 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 que devuelva "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 que devuelva "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 que devuelva "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 aparte):
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 carga de 10.5 toneladas y una Motorcycle con sidecar. Guarda 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. Al terminar, libera los objetos asignados dinámicamente.

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 real del objeto coincide con el tipo de destino. Para cada vehículo, solo una de las tres conversiones tendrá éxito, lo que te permitirá 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() {
    // Lee las entradas
    string carPlate, truckPlate, motorcyclePlate;
    cin >> carPlate;
    cin >> truckPlate;
    cin >> motorcyclePlate;

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

    // TODO: Guarda 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 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()
    //   6. Imprime una línea en blanco entre las inspecciones de cada vehículo

    // TODO: Libera los objetos asignados dinámicamente

    return 0;
}