static_cast vs dynamic_cast vs C-style cast: cómo no romper el código

Introducción: por qué la conversión de tipos en C++ es un campo minado

¿Alguna vez has escrito algo como (int)someFloat y esperabas que todo estuviera bien? ¿O quizás te has encontrado con una situación en la que el programa compila, pero falla en tiempo de ejecución con un error misterioso? Bienvenido al mundo de la conversión de tipos en C++: un lugar donde incluso los desarrolladores experimentados pierden horas depurando.

La pregunta "Regular cast vs. static_cast vs. dynamic_cast" en Stack Overflow ha acumulado decenas de miles de visitas. Y no es casualidad. Cada tipo de conversión es una herramienta con su propio propósito, y usar la herramienta incorrecta puede provocar un comportamiento indefinido, fugas de memoria o simplemente un código que no funciona.

En este artículo, analizaremos las tres formas principales de conversión de tipos en C++, mostraremos los errores más comunes y daremos recomendaciones claras sobre cómo evitarlos. Al final, sabrás exactamente qué cast usar en cada situación concreta.

1. Regular cast (C-style cast) — herencia del pasado

El viejo y conocido C-style cast es la forma más simple, pero al mismo tiempo la más peligrosa de conversión. Se ve así: (NewType)expression. En C++, se considera "regular", pero su comportamiento puede sorprenderte mucho.

¿Cómo funciona?

El compilador de C++ intenta interpretar el C-style cast como una secuencia de static_cast, const_cast y reinterpret_cast. Elige la primera combinación que sea válida. El problema es que nunca sabes qué cast exacto se aplicará al final.

Ejemplo de error: cambio accidental de constancia

const int value = 42;\nint* ptr = (int*)&value;  // C-style cast elimina const\n*ptr = 100;               // ¡Comportamiento indefinido!\ncout << value;           // Puede mostrar 42, 100 o cualquier cosa

Este código compila sin errores, pero provoca un comportamiento indefinido. const_cast aquí habría sido más honesto: al menos muestra tu intención.

¿Cuándo sigue siendo aceptable el C-style cast?

\n
• Nunca en C++ moderno (C++11 y posteriores).
\n
• Solo para conversiones numéricas muy simples donde el riesgo es mínimo (por ejemplo, (float)intValue), pero incluso entonces es mejor usar static_cast.
\n

Conclusión: olvídate del C-style cast. Hace que el código sea ilegible e inseguro. Los compiladores modernos incluso pueden emitir advertencias sobre estas construcciones.

2. static_cast — el soldado universal

static_cast es el tipo de conversión más utilizado en C++. Realiza la verificación en tiempo de compilación y es adecuado para la mayoría de las situaciones donde la conversión de tipos es lógicamente correcta.

¿Cuándo usar static_cast?

\n
• Conversión de tipos numéricos: double → int, int → float.
\n
• Upcast (conversión de un puntero a una clase derivada a un puntero a la clase base).
\n
• Conversión explícita de void* de vuelta a un tipo específico.
\n
• Llamada a constructores con un solo argumento (pero es mejor usar explicit).
\n

Ejemplo: upcast correcto

class Base { public: virtual void speak() { cout << "Base"; } };\nclass Derived : public Base { public: void speak() override { cout << "Derived"; } };\n\nDerived d;\nBase* b = static_cast<Base*>(&d);  // upcast — seguro\nb->speak();  // Mostrará "Derived" gracias a la función virtual

Error principal #1: Slicing al pasar por valor

Uno de los errores más engañosos es el slicing (corte del objeto). Ocurre cuando conviertes un objeto de una clase derivada a la clase base por valor, en lugar de por referencia o puntero