Programação C: Dominando Type Casting e Conversão de Tipos
Converter um tipo de dado em outro é conhecido como type casting ou conversão de tipos. Por exemplo, se você quiser armazenar um valor 'long' em um inteiro simples, pode fazer type cast de 'long' para 'int'. Você pode converter valores de um tipo para outro explicitamente usando o operador de cast da seguinte forma:
(nome_tipo) expressão
Considere o seguinte exemplo onde o operador de cast faz a divisão de uma variável inteira por outra ser realizada como uma operação de ponto flutuante:
Demo ao vivo #include <stdio.h> main() { int soma = 17, contador = 5; double media; media = (double) soma / contador; printf("Valor da média: %f\n", media); } Quando o código acima é compilado e executado, produz o seguinte resultado:
Valor da média: 3.400000
Deve-se notar que o operador de cast tem precedência sobre a divisão, então o valor de soma é primeiro convertido para o tipo double e finalmente é dividido por contador, resultando em um valor double.
Conversões de tipo podem ser implícitas, realizadas automaticamente pelo compilador, ou podem ser especificadas explicitamente através do uso do operador de cast. É considerada uma boa prática de programação usar o operador de cast sempre que conversões de tipo forem necessárias.
Promoção de Inteiros
A promoção de inteiros é o processo pelo qual valores de tipo inteiro "menores" que int ou unsigned int são convertidos para int ou unsigned int. Considere um exemplo de adição de um caractere com um inteiro:
Demo ao vivo #include <stdio.h> main() { int i = 17; char c = 'c'; /* valor ascii é 99 */ int soma; soma = i + c; printf("Valor da soma: %d\n", soma); } Quando o código acima é compilado e executado, produz o seguinte resultado:
Valor da soma: 116
Aqui, o valor da soma é 116 porque o compilador está fazendo promoção de inteiro e convertendo o valor de 'c' para ASCII antes de realizar a operação de adição real.
Conversão Aritmética Usual
As conversões aritméticas usuais são realizadas implicitamente para converter seus valores para um tipo comum. O compilador primeiro realiza a promoção de inteiros; se os operandos ainda tiverem tipos diferentes, eles são convertidos para o tipo que aparece mais alto na seguinte hierarquia:
As conversões aritméticas usuais não são realizadas para operadores de atribuição, nem para os operadores lógicos && e ||. Vamos pegar o seguinte exemplo para entender o conceito:
Demo ao vivo #include <stdio.h> main() { int i = 17; char c = 'c'; /* valor ascii é 99 */ float soma; soma = i + c; printf("Valor da soma: %f\n", soma); } Quando o código acima é compilado e executado, produz o seguinte resultado:
Valor da soma: 116.000000
Aqui, é simples entender que primeiro c é convertido para inteiro, mas como o valor final é double, a conversão aritmética usual se aplica e o compilador converte i e c para 'float' e os soma, resultando em um resultado 'float'.
Linguagem C
- Dominando Conversão de Tipos em C#: Implícita, Explícita, Parse e Métodos Convert
- Dominando Conversão e Casting de Tipos em Python: Guia Completo
- Dominando Type Casting em Java: De Widening a Narrowing e Além
- Tipos de Variáveis em C++ Explicados: Memória, Limites e Operações
- Guia Completo dos Tipos de Dados em C#: Valor, Referência e Ponteiro
- Entendendo Conversão de Tipos em C#: Casting Implícito e Explícito Explicados
- Entendendo Tipos Anuláveis (Nullable) em C#: Tratando Valores Null com Segurança
- Dominando Atributos em C#: Enriqueça Código com Metadados
- Fundição sob Pressão Explicada: Precisão, Eficiência e Benefícios de Produção
- Guia Definitivo de Fundição de Precisão: Técnicas e Aplicações