Em C++, as conversões de tipo explícitas permitem controlar como os dados são interpretados antre diferentes tipos. O fornece quatro operadores principais para isso, cada um com propósitos específicos e níveis de segurança variados.

static_cast

Este operador é adequado para conversões em que a relação entre os tipos é conhecida em tempo de compilação. É frequentemente usado para conversões entre tipos básicos, como de float para int, ou para converter ponteiros em hierarquias de classes sem polimorfismo, como de uma classe base para uma derivada. Para conversões de ponteiros void* para outros tipos de ponteiros também é aplicável.

float media = 5.9f;
int arredondado = static_cast<int>(media); // Conversão de tipo básico

class Animal {};
class Cachorro : public Animal {};
Animal* ptr_animal = new Cachorro;
Cachorro* ptr_cachorro = static_cast<Cachorro*>(ptr_animal); // Conversão para baixo (requer cautela do desenvolvedor)

Este operador não realiza verificações em tempo de erro; conversões incorretas, especialmente em hierarquias de classes, podem levar a comportamentos indefinidos. Ele não pode remover qualificadores como const — para isso, use const_cast.

dynamic_cast

Este é o operador preferido para conversões seguras em hierarquias de classes polimórficas, ou seja, classes que possuem pelo menos uma função virtual. Ele realiza uma verificação em tempo de execução para garantir que a conversão seja válida. Para ponteiros, retorna nullptr em caso de falha; para referências, lança uma exceção std::bad_cast.

class Forma { virtual void desenhar() {} }; // Necessita de função virtual
class Circulo : public Forma {};

Forma* ptr_forma = new Circulo;
Circulo* ptr_circulo = dynamic_cast<Circulo*>(ptr_forma); // Conversão segura

if (ptr_circulo) {
    // A conversão foi bem-sucedida
}

Este operador depende de Informações de Tipo em Tempo de Execução (RTTI), o que pode impactar o desempenho. Ele só pode ser usado com classes polimórficas.

const_cast

Utilizado para adicionar ou remover qualificadores const ou volatile de uma variável. Uma aplicação comum é adaptar código legado que não utiliza esses qualificadores corretamente, permitindo passar argumentos const para funções que esperam versões não constantes.

const int valor = 42;
int* ptr_modificavel = const_cast<int*>(&valor); // Remove o const (mas modificar valor é comportamento indefinido!)

void funcao_antiga(char* texto);
const char* mensagem = "teste";
funcao_antiga(const_cast<char*>(mensagem)); // Compatibilidade com interface legada

Modificar um objeto que foi originalmente declarado como const através deste cast é comportamento indefinido e pode causar falhas. Seu uso deve ser restrito a situações onde a remoção do qualificador é estritamente necessária e as consequências são compreendidas.

reinterpret_cast

Este operador executa uma reinterpretação de baixo nível do padrão de bits, alterando a forma como o dado é tratado sem alterar seu valor binário. É usado para converter entre ponteiros de tipos não relacionados, ou entre ponteiros e tipos inteiros de tamanho adequado.

int numero = 0xAABBCCDD;
char* bytes = reinterpret_cast<char*>(&numero); // Converte int* para char* para inspecionar bytes

uintptr_t endereco = reinterpret_cast<uintptr_t>(bytes); // Converte ponteiro para inteiro (dependente de plataforma)

Conversões com reinterpret_cast são altamente dependentes da arquitetura e do compilador, sendo portanto não portáveis. Elas são propensas a causar comportamentos indefinidos, como violações de alinhamento de memória.

Comparação com a Conversão no Estilo C

A sintaxe de conversão do C, como (int)3.14, tenta aplicar uma sequência de operadores: primeiro const_cast, depois static_cast, seguido por reinterpret_cast, em combinações possíveis. Esta abordagem oculta a intenção específica da conversão, tornando o código mais propenso a erros difíceis de depurar e oferecendo controle precário sobre o comportamento.

Recomenda-se priorizar static_cast e dynamic_cast por sua clareza e segurança relativa. const_cast e reinterpret_cast devem ser evitados a menos que estritamente necessários e com pleno entendimento de seus riscos.