1. Introdução
Já tentou enfiar uma melancia dentro de uma garrafa? Pois é, o C# passa por algo parecido toda vez que você pede pra ele colocar uma variável de um tipo em outro. Às vezes é tranquilo (transformar um número pequeno em um grande — tipo colocar uma maçã numa mala), mas às vezes tem que tomar cuidado (melancia na garrafa — aí não rola sem dor de cabeça).
Conversão de tipo é a operação de transformar um valor de um tipo de dado em outro. Isso rola direto quando você quer somar ou comparar valores de tipos diferentes, ou passar eles pra métodos que aceitam só um tipo específico.
Na vida real de dev, isso aparece o tempo todo: você faz pagamento, calcula desconto, faz conta de física ou, por exemplo, faz parse de números digitados pelo usuário no teclado (lá tudo chega como string).
2. Conversão implícita de tipos (Implicit Conversion)
O que é isso?
Conversão implícita é quando o C# decide sozinho que dá pra “mover” os dados de um tipo pra outro sem dor. Tudo acontece automático — você não escreve nada, só usa os valores.
- O compilador não reclama.
- Não precisa de comando especial nem cast.
- Não tem perda de dados (bom, quase nunca).
Exemplo de conversão implícita
int a = 42;
double b = a; // Conversão implícita int -> double
Console.WriteLine(b); // 42 (mas agora é 42.0)
Aqui o a do tipo int vira automaticamente double quando é atribuído pra variável b. Não tem perda de dados, porque todo valor de int cabe fácil num double.
Aqui o a do tipo int vira automaticamente double quando é atribuído pra variável b. Não tem perda de dados, porque todo valor de int cabe fácil num double.
Quando isso funciona?
- Quando o tipo de destino é maior que o tipo de origem — suporta um intervalo de dados maior.
- Não rola perda de dados.
- Exemplos:
- int → long
- int → float / double
- float → double
- char → int
Outro exemplo:
byte x = 100;
int y = x; // byte -> int (todo valor de byte cabe no intervalo de int)
Tabela de conversão implícita para tipos numéricos
| De | Para |
|---|---|
|
|
|
|
|
|
|
|
3. Conversão explícita de tipos (Explicit Conversion, Type Cast)
Quando a mágica não basta?
Às vezes o compilador não consegue garantir que a conversão vai ser segura, e aí ele joga a responsa pra você — tem que avisar explicitamente que tá ligado no risco.
- Pode ser que você perca dados.
- O formato do valor pode mudar.
- Às vezes a conversão nem rola — vai dar erro.
Como escrever conversão explícita?
Usa a sintaxe de parênteses (cast):
double pi = 3.1415;
int wholePi = (int)pi; // Conversão explícita double -> int
Console.WriteLine(wholePi); // 3 (a parte decimal é jogada fora!)
Quando usar?
- Quando o tipo de destino é menor que o tipo de origem — o intervalo do destino é menor que o do tipo de origem.
- Pode perder a parte decimal, dados, ou até dar overflow.
- Exemplos:
- double → int
- long → int
- int → byte
- Quase qualquer conversão entre tipos incompatíveis.
4. Bora ver exemplos
1) Perde dado? Bora testar!
Conversão implícita — tudo certo!
int small = 25;
long big = small; // Conversão implícita (int -> long)
Console.WriteLine(big); // 25
Conversão explícita — zona de perigo!
int big = 1000;
byte small = (byte)big; // Conversão explícita (int -> byte)
Console.WriteLine(small); // 232 (!), porque 1000 não cabe em byte (0..255)
Aqui o resultado é o “mágico” 232, porque 1000 % 256 == 232.
2) Com números de ponto flutuante (double, float)
double number = 9.99;
int approximate = (int)number; // a parte decimal é simplesmente jogada fora
Console.WriteLine(approximate); // 9
3) Conversão entre inteiros e reais (double ↔ int)
int apples = 5;
double exactApples = apples; // int -> double (implícito)
Console.WriteLine(exactApples); // 5.0
double bananaWeight = 2.77;
int weightForReport = (int)bananaWeight; // double -> int (explícito)
Console.WriteLine(weightForReport); // 2
5. E pra converter strings: Parse e Convert
Conversão de tipo não funciona entre número e string! Aqui tem que usar métodos especiais, tipo:
string strNumber = "123";
int num = int.Parse(strNumber); // ou Convert.ToInt32(strNumber);
Mas o contrário (int → string) rola automático quando junta com string:
int number = 42;
string message = "Resposta: " + number; // Conversão implícita int → string
6. Erros na conversão de tipos
Momento história: uma vez alguém esqueceu de fazer conversão explícita, e o pagamento final ficou 250 vezes menor do que devia... Galera, fiquem ligados!
Erro comum: tentar converter implicitamente um tipo onde pode perder dados.
int big = 500;
byte small = big; // Compilador: "Não pode! Pode perder dados!"
Aqui vai precisar de conversão explícita:
byte small = (byte)big; // Mas você pode perder dados!
Outro bug famoso — esqueceu da parte decimal:
double x = 2.9;
int y = (int)x; // y == 2, parte decimal sumiu
Pra arredondar do jeito certo, usa Math.Round:
int y = (int)Math.Round(x); // y == 3
7. Pegadinhas de conversão
- Perda de dados. Sempre confere se o valor não passa do intervalo do tipo. Por exemplo, int vai de -2 147 483 648 até 2 147 483 647, e byte só de 0–255.
- Arredondamento. Conversão normal ((int)x) só joga fora a parte decimal. Pra arredondar certo, usa Math.Round, Math.Floor, Math.Ceiling.
- Literais numéricos. Fica ligado: 3 / 2 dá 1 (divisão inteira), mas 3.0 / 2 já dá 1.5 (double)!
- Operações com tipos mistos. Se misturar, por exemplo, int e double numa expressão, o resultado vai ser do tipo double.
GO TO FULL VERSION