🔄 Conversões de Tipos · Casts em C/C++

🔄 Conversões de Tipos

"Conversão de tipo (type casting) é o processo de transformar um valor de um tipo de dado para outro, seja implicitamente pelo compilador ou explicitamente pelo programador."

Em C/C++, valores frequentemente precisam ser convertidos entre tipos diferentes — por exemplo, ao atribuir um int a um float, ou ao passar argumentos para funções. Compreender como e quando essas conversões ocorrem é crucial para evitar perda de dados, comportamentos inesperados e bugs sutis.

🔄 Conversões Implícitas (Automáticas)

O compilador realiza conversões implícitas automaticamente quando tipos diferentes são usados em expressões. Elas seguem uma hierarquia de promoção para evitar perda de dados.

Hierarquia de Tipos (do menor para o maior)

// bool → char → short → int → long → long long
// float → double → long double

int i = 42;
double d = i;        // Conversão implícita de int para double (d = 42.0)

char c = 'A';
int codigo = c;      // Conversão implícita de char para int (codigo = 65)

float f = 3.14f;
double d2 = f;       // Conversão implícita de float para double
  

Promoções vs. Conversões de Estreitamento

Promoção (widening): Conversão para um tipo maior — geralmente segura, sem perda de dados.
Estreitamento (narrowing): Conversão para um tipo menor — pode causar perda de dados ou precisão.

double d = 3.14159;
int i = d;            // Estreitamento: i = 3 (perda da parte fracionária)

int grande = 1000;
char c = grande;     // Estreitamento perigoso: overflow! (c = -24 ou outro valor)
  

⚠️ Cuidado com Estreitamento! Em C++11 e posteriores, a inicialização uniforme {} proíbe conversões de estreitamento, gerando erro de compilação. Prefira essa sintaxe para maior segurança.

📝 Conversões Explícitas (Casting)

Quando o programador força uma conversão, isso é chamado de casting explícito. C oferece uma sintaxe, enquanto C++ oferece operadores mais seguros e específicos.

Cast Estilo C (Evitar em C++)

double d = 3.14;
int i = (int)d;        // Cast estilo C: i = 3

int valor = 65;
char c = (char)valor;   // c = 'A'

int* p = (int*)0x1000;  // Muito perigoso! Sem verificação de tipo
  

O cast estilo C é poderoso, mas perigoso. Ele pode realizar qualquer conversão sem avisos, incluindo reinterpretações brutais de ponteiros, e não deixa claro a intenção do programador.

🛡️ Operadores de Cast do C++

C++ introduziu quatro operadores de cast que são mais seguros, expressivos e fáceis de localizar no código.

🔹 static_cast

Conversões bem definidas e seguras em tempo de compilação. Equivalente ao cast implícito, mas explícito.

static_cast<int>(3.14)

🔹 dynamic_cast

Conversão segura em hierarquias de classes (polimorfismo). Verifica o tipo em tempo de execução.

dynamic_cast<Derivada*>(base)

🔹 const_cast

Adiciona ou remove o qualificador const (ou volatile) de uma variável.

const_cast<char*>(str)

🔹 reinterpret_cast

Conversão de baixo nível entre tipos não relacionados (ex.: ponteiro para inteiro). Muito perigoso!

reinterpret_cast<int*>(0x1000)

📌 static_cast

Usado para conversões implícitas bem definidas, como entre tipos numéricos, ou upcasting em herança.

double d = 3.14159;
int i = static_cast<int>(d);        // i = 3

char c = static_cast<char>(65);        // c = 'A'

class Base {};
class Derivada : public Base {};
Derivada d_obj;
Base* b = static_cast<Base*>(&d_obj);   // Upcast seguro
  

📌 dynamic_cast

Usado exclusivamente com hierarquias de classes polimórficas (com funções virtuais). Verifica se a conversão é válida em tempo de execução.

class Animal { public: virtual ~Animal() {} };
class Cachorro : public Animal { public: void latir() {} };
class Gato : public Animal {};

Animal* a = new Cachorro();

Cachorro* c = dynamic_cast<Cachorro*>(a);   // Sucesso: não é nullptr
Gato* g = dynamic_cast<Gato*>(a);         // Falha: retorna nullptr

if (c != nullptr) {
    c->latir();   // Seguro!
}
  

📌 const_cast

Remove ou adiciona const (ou volatile). Útil principalmente para interoperar com APIs legadas que não usam const corretamente.

void funcaoLegada(char* str) {   // Não modifica str, mas não é const
    cout << str << endl;
}

const char* msg = "Olá, mundo!";
funcaoLegada(const_cast<char*>(msg));   // Remove const para a chamada
  

⚠️ Cuidado! Modificar um valor originalmente declarado como const após usar const_cast resulta em comportamento indefinido. Use com extrema cautela.

📌 reinterpret_cast

O cast mais perigoso. Reinterpreta o padrão de bits de um tipo como se fosse outro. Dependente de plataforma e facilmente causa erros catastróficos.

int valor = 42;
char* bytes = reinterpret_cast<char*>(&valor);
// Agora bytes[0], bytes[1], bytes[2], bytes[3] acessam os bytes individuais do int

// Exemplo de uso legítimo (mas raro):
uintptr_t endereco = reinterpret_cast<uintptr_t>(&valor);
cout << "Endereço de valor: " << std::hex << endereco << endl;
  

📊 Comparação dos Operadores de Cast

Operador	Verificação	Quando Usar	Nível de Segurança
`static_cast`	Compilação	Conversões numéricas, upcasting	🟢 Alto
`dynamic_cast`	Execução	Downcasting em hierarquias polimórficas	🟢 Alto (retorna nullptr se falha)
`const_cast`	Compilação	Remover/adicionar const ou volatile	🟡 Médio (risco de comportamento indefinido)
`reinterpret_cast`	Compilação	Conversões de baixo nível, ponteiros	🔴 Baixo (muito perigoso)
Cast estilo C	Compilação	Evitar em C++	🔴 Baixo (combina todos acima sem clareza)

🔗 Conclusão

Conversões de tipo são inevitáveis, mas devem ser usadas com consciência. Em C++, prefira sempre os operadores de cast explícitos: eles documentam a intenção, restringem o escopo da conversão e ajudam a evitar erros. O static_cast cobre a maioria dos casos legítimos. dynamic_cast é indispensável para downcasting seguro. const_cast e reinterpret_cast devem ser usados com parcimônia e apenas quando absolutamente necessário.

⏭️ Próximo: Laços e Condicionais...