Conversores static_cast, dynamic_cast y const_cast en C++

double numeroDecimal = 9.99;
int numeroEntero = static_cast<int>(numeroDecimal); // Conversión explícita

En este caso, se convierte el valor double a un int, perdiendo la parte decimal del número de manera consciente. Al usar static_cast, se asegura una conversión clara y el programador es responsable de esta pérdida de precisión.

class Base {};
class Derivada : public Base {};

Base* basePtr = new Derivada();
Derivada* derivadaPtr = static_cast<Derivada*>(basePtr); // Conversión válida

Aquí, static_cast convierte un puntero de clase base (Base*) a un puntero de una clase derivada (Derivada*). La conversión es válida porque basePtr en realidad apunta a un objeto de la clase derivada.

class Base {
public:
    virtual void metodo() {}  // Clase polimórfica porque tiene al menos una función virtual
};

class Derivada : public Base {
public:
    void metodo() override {}
};

Base* basePtr = new Derivada();
Derivada* derivadaPtr = dynamic_cast<Derivada*>(basePtr); // Conversión válida

En este ejemplo,

• dynamic_cast convierte correctamente el puntero basePtr (de tipo Base*) a un puntero Derivada*.
• Si basePtr no apuntara a un objeto de la clase Derivada, dynamic_cast devolvería nullptr (evitando errores como accesos ilegales a memoria)

Base* basePtr = new Base();
Derivada* derivadaPtr = dynamic_cast<Derivada*>(basePtr);

if (derivadaPtr == nullptr) {
    std::cout << "La conversión no fue exitosa." << std::endl;
}

Aquí, la conversión falla porque basePtr no apunta a un objeto de tipo Derivada, y el puntero derivadaPtr es nullptr.

const int numeroConstante = 42;
int* ptr = const_cast<int*>(&numeroConstante); // Elimina const
*ptr = 100;  // Comportamiento indefinido: modificar una variable const

En este caso,

• const_cast se usa para eliminar el calificador const de numeroConstante

const_cast también puede ser útil cuando se trabaja con funciones que no marcan correctamente sus parámetros como const.

Por ejemplo, si tienes una función de una API que toma un puntero no const, pero sabes que no modifica el valor:

void funcionQueNoModifica(int* ptr) {
    // No modifica el valor
}

const int numero = 50;
funcionQueNoModifica(const_cast<int*>(&numero));  // Conversión legítima

int numero = 65;
char* letraPtr = reinterpret_cast<char*>(&numero);
std::cout << *letraPtr << std::endl;  // Imprime 'A', que es el carácter ASCII para 65

En este ejemplo:

• reinterpret_cast convierte la dirección de memoria del entero numero en un puntero char*.
• Esto permite interpretar los primeros bytes de la representación binaria de numero como un carácter ASCII.

int numero = 42;
uintptr_t ptrAsInt = reinterpret_cast<uintptr_t>(&numero);  // Convierte un puntero en un entero sin signo
std::cout << ptrAsInt << std::endl;

Aquí, el puntero a numero es convertido a un número entero sin signo de tipo uintptr_t (un tipo especial que puede almacenar direcciones de memoria). Esto puede ser útil cuando necesitas trabajar con direcciones de memoria en un contexto específico, pero en general, no se recomienda abusar de este tipo de conversiones.