C# Academy · Aula

Conversões implícitas e explícitas

Converta tipos compatíveis com segurança.

Conversões implícitas e explícitas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Convertendo entre tipos

C# pode converter um tipo numérico em outro. Algumas conversões ocorrem automaticamente (implícitas), enquanto outras exigem uma conversão explícita.

using System;

class Program
{
    static void Main()
    {
        int i = 10;
        double d = i;       // implicit
        int back = (int)d;   // explicit
        Console.WriteLine(d + ", " + back);
    }
}

Conversões implícitas (de ampliação)

Uma conversão implícita é permitida quando nenhum dado pode ser perdido, como de int para long ou de int para double. Nenhuma conversão explícita é necessária.

using System;

class Program
{
    static void Main()
    {
        int i = 42;
        long l = i;      // widening, safe
        double d = i;    // widening, safe
        Console.WriteLine(l + ", " + d);
    }
}

Por que a ampliação é segura

O tipo de destino pode representar todos os valores do tipo de origem, portanto o compilador permite a conversão silenciosamente.

using System;

class Program
{
    static void Main()
    {
        byte b = 200;
        int i = b;       // byte fits in int
        Console.WriteLine("byte " + b + " -> int " + i);
    }
}

Conversões explícitas (de redução)

Uma conversão explícita é necessária quando os dados podem ser perdidos, como de double para int. Você escreve (int)value.

using System;

class Program
{
    static void Main()
    {
        double d = 9.78;
        int i = (int)d;   // truncates toward zero -> 9
        Console.WriteLine(i);
    }
}

A conversão trunca, não arredonda

Converter um valor de ponto flutuante para um inteiro descarta a parte fracionária; não faz arredondamento. Use Math.Round primeiro se quiser arredondar.

using System;

class Program
{
    static void Main()
    {
        double d = 7.99;
        Console.WriteLine("Cast: " + (int)d);
        Console.WriteLine("Round: " + (int)Math.Round(d));
    }
}

Estouro na redução

Se um valor não couber no tipo de destino, uma conversão simples pode causar uma volta ao início silenciosamente. Envolva-a em checked para gerar um erro de estouro.

using System;

class Program
{
    static void Main()
    {
        int big = 300;
        byte wrapped = (byte)big;   // 300 wraps to 44
        Console.WriteLine("Wrapped: " + wrapped);

        try
        {
            byte safe = checked((byte)big);
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("checked caught overflow");
        }
    }
}

Perda de precisão

Até algumas conversões de ampliação, como de um long muito grande para float, podem perder precisão, embora continuem sendo implícitas.

using System;

class Program
{
    static void Main()
    {
        long big = 9007199254740993L;
        double approx = big;   // implicit, may lose precision
        Console.WriteLine("long: " + big);
        Console.WriteLine("double: " + approx.ToString("F0"));
    }
}

caractere e conversões numéricas

Um char é convertido implicitamente para seu código numérico, e você pode converter explicitamente um número de volta para um char.

using System;

class Program
{
    static void Main()
    {
        char c = 'A';
        int code = c;          // implicit -> 65
        char next = (char)(code + 1);   // explicit -> B
        Console.WriteLine(code + " -> " + next);
    }
}

Conversões em expressões

Em operações aritméticas mistas, os tipos menores são promovidos automaticamente para o tipo maior antes da operação.

using System;

class Program
{
    static void Main()
    {
        int a = 7;
        double b = 2;
        double result = a / b;   // a promoted to double -> 3.5
        Console.WriteLine(result);
    }
}

Armadilha da divisão inteira

Se os dois operandos forem inteiros, a divisão será uma divisão inteira. Converta primeiro um deles para double para obter um resultado fracionário.

using System;

class Program
{
    static void Main()
    {
        int a = 7, b = 2;
        Console.WriteLine("int / int: " + (a / b));
        Console.WriteLine("with cast: " + ((double)a / b));
    }
}

Colocando tudo em conjunto

Prefira conversões implícitas quando forem seguras, use conversões explícitas ao reduzir o tipo e fique atento a truncamentos, estouros e divisões inteiras.

using System;

class Program
{
    static void Main()
    {
        int total = 17, count = 5;
        double average = (double)total / count;   // cast to avoid integer division
        int rounded = (int)Math.Round(average);
        Console.WriteLine("avg=" + average + ", rounded=" + rounded);
    }
}

Verificação rápida

Teste sua compreensão sobre conversões.

Recapitulação

As conversões implícitas (de ampliação) ocorrem automaticamente quando nenhum dado é perdido (de int para long, de int para double). As conversões explícitas (de redução) exigem uma conversão como (int)x e podem truncar ou causar estouro. Use checked para detectar estouros e converta para double para evitar a divisão inteira.

using System;

class Program
{
    static void Main()
    {
        double d = 3.9;
        int i = (int)d;     // explicit, truncates to 3
        long l = i;          // implicit widening
        Console.WriteLine(i + ", " + l);
    }
}

Perguntas Frequentes

A aula “Conversões implícitas e explícitas” é grátis?

Sim — o texto completo de “Conversões implícitas e explícitas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Conversões implícitas e explícitas”?

Converta tipos compatíveis com segurança. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Conversões implícitas e explícitas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Tipos de valor versus tipos de referência
Boxing e unboxing
Conversões implícitas e explícitas
A classe Convert e análise

← Voltar para C# Academy