C# Academy · Lekcja

Konwersje niejawne i jawne

Bezpiecznie konwertuj między zgodnymi typami.

Konwersje niejawne i jawne to bezpłatna lekcja C# Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C# Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C# Academy zawiera 4 lekcji w sumie.

Konwersja między typami

C# umożliwia konwersję jednego typu liczbowego na inny. Niektóre konwersje zachodzą automatycznie (niejawnie), podczas gdy inne wymagają jawnego rzutowania.

using System;

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

Konwersje niejawne (poszerzające)

Konwersja niejawna jest dozwolona, gdy nie może dojść do utraty danych, na przykład przy konwersji int na long lub int na double. Rzutowanie nie jest potrzebne.

using System;

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

Dlaczego konwersja poszerzająca jest bezpieczna

Typ docelowy może reprezentować każdą wartość typu źródłowego, dlatego kompilator zezwala na tę konwersję bez dodatkowych instrukcji.

using System;

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

Konwersje jawne (zawężające)

Konwersja jawna (rzutowanie) jest wymagana, gdy może dojść do utraty danych, na przykład przy konwersji double na int. Należy napisać (int)value.

using System;

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

Rzutowanie obcina, a nie zaokrągla

Rzutowanie wartości zmiennoprzecinkowej na całkowitą usuwa część ułamkową, ale nie zaokrągla wartości. Jeśli potrzebują Państwo zaokrąglenia, należy najpierw użyć Math.Round.

using System;

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

Przepełnienie przy konwersji zawężającej

Jeśli wartość nie mieści się w typie docelowym, zwykłe rzutowanie może po cichu zawinąć wartość. Należy umieścić je w kontekście checked, aby zamiast tego zgłosić przepełnienie.

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");
        }
    }
}

Utrata precyzji

Nawet niektóre konwersje poszerzające, takie jak konwersja bardzo dużej wartości long na float, mogą powodować utratę precyzji, mimo że nadal są niejawne.

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"));
    }
}

Konwersje char i typów liczbowych

Typ char jest niejawnie konwertowany na swój kod liczbowy, a liczbę można jawnie rzutować z powrotem na 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);
    }
}

Konwersje w wyrażeniach

W działaniach arytmetycznych na różnych typach mniejsze typy są automatycznie konwertowane na większy typ przed wykonaniem operacji.

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);
    }
}

Pułapka dzielenia całkowitoliczbowego

Jeśli oba operandy są liczbami całkowitymi, dzielenie również jest całkowitoliczbowe. Aby uzyskać wynik ułamkowy, należy najpierw rzutować jeden z operandów na double.

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));
    }
}

Podsumowanie całości

Należy preferować konwersje niejawne, gdy są bezpieczne, używać jawnego rzutowania przy konwersjach zawężających oraz zwracać uwagę na obcinanie, przepełnienie i dzielenie całkowitoliczbowe.

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);
    }
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat konwersji.

Powtórzenie

Konwersje niejawne (poszerzające) zachodzą automatycznie, gdy nie dochodzi do utraty danych (int na long, int na double). Konwersje jawne (zawężające) wymagają rzutowania, takiego jak (int)x, i mogą powodować obcinanie lub przepełnienie. Należy używać checked, aby wykrywać przepełnienia, oraz rzutować na double, aby unikać dzielenia całkowitoliczbowego.

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);
    }
}

Często zadawane pytania

Czy lekcja „Konwersje niejawne i jawne” jest bezpłatna?

Tak — pełny tekst „Konwersje niejawne i jawne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C# Academy, przejdź na CoddyKit PRO. Kurs C# Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Konwersje niejawne i jawne”?

Bezpiecznie konwertuj między zgodnymi typami. Ćwiczysz C# Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C# Academy?

Nie wymagamy żadnego doświadczenia. C# Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Konwersje niejawne i jawne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C# Academy?

Tak. Każda lekcja C# Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C# Academy