Introdução aos Operadores de Conversão em C++

Em C++, a conversão de tipos é um recurso poderoso, mas deve ser usado com cuidado. Existem quatro operadores específicos para realizar conversões explícitas: static_cast, dynamic_cast, const_cast e reinterpret_cast. Cada um tem um propósito distinto e níveis diferentes de segurança.

Conversão Estática: static_cast

static_cast realiza conversões durante a compilação e não verifica a validade do tipo em tempo de execução. Ele é ideal para conversões seguras entre tipos relacionados, como números ou hierarquias de classes com polimorfismo.

• Em herança, permite conversão ascendente (de derivada para base), que é sempre segura.
• Para conversão descendente (de base para derivada), static_cast permite a operação, mas não garante a integridade do objeto — pode causar comportamento indefinido se o objeto real não for da classe esperada.
• Também é usado para conversões simples entre tipos primitivos, como int para double:

double result = static_cast<double>(5) / 2; // Resulta em 2.5

Além disso, pode converter pontieros void* para qualquer tipo, embora isso seja perigoso e deva ser evitado quando possível.

Conversão Dinâmica: dynamic_cast

dynamic_cast realiza verificação em tempo de execução. É seguro apenas quando há uma relação de herança polimórfica (ou seja, a classe base possui pelo menos um método virtual).

• Na conversão ascendente, seu comportamento é idêntico ao de static_cast.
• Na conversão descendente, retorna nullptr (para potneiros) ou lança uma exceção (para referências) se o tipo do objeto não corresponder ao esperado.
• Só funciona com ponteiros ou referências a objetos com vtable (classes polimórficas).
• Pode ser usado para converter para void* desde que o objeto seja completo:

class Base { virtual void dummy() {} };
int main() {
    Base* ptr = new Base;
    void* raw = dynamic_cast<void*>(ptr);
    return 0;
}

Manipulação de Qualificadores: const_cast

O único operador capaz de alterar a qualificação const ou volatile de um tipo.

• Remove const:

const int value = 42;
int* mutablePtr = const_cast<int*>(&value);
*mutablePtr = 100; // Comportamento indefinido! Não modifique dados const.

• Adiciona const:

int data = 10;
const int* constPtr = const_cast<const int*>(&data);
// *constPtr = 5; // Erro de compilação: tentativa de modificar valor const.

Usar const_cast para remover const de dados originais é inseguro e deve ser evitado.

Conversão Bruta: reinterpret_cast

Realiza conversão de ponteiros sem verificar compatibilidade de tipo. É extremamente perigosa e deve ser usado apenas em casos muito específicos, como manipulação de bits ou interoperabilidade com código C.

• Permite converter qualquer tipo de ponteiro para outro, mesmo entre tipos sem relação lógica.
• Não realiza verificação alguma em tempo de execução.
• Exemplo:

int num = 42;
double* fp = reinterpret_cast<double*>(&num); // Converte int para double, mas valores serão imprevisíveis.

Este tipo de conversão pode levar a falhas de segmentação ou resultados incorretos.