Typy danych w C#: int, double, decimal, char, bool i ich zakresy

C# jest typowany statycznie: każda zmienna, pole i wyrażenie ma typ znany w czasie kompilacji. Język ma zestaw typów wbudowanych z własnymi słowami kluczowymi (int, double, string...). Każde słowo kluczowe to alias typu z przestrzeni nazw System, więc int i System.Int32 to ten sam typ, a string i System.String to ten sam typ.

Typy wbudowane

Literał całkowity bez przyrostka ma typ int, a jeśli jest za duży na int, to pierwszy z typów uint, long i ulong, który go pomieści; literał z kropką dziesiętną ma typ double. Dlatego float f = 2.5; i decimal d = 2.5; się nie kompilują: literał jest typu double, a nie ma niejawnej konwersji z double na float ani decimal. Dodaj przyrostek: 2.5f, 2.5m.

Każdy typ liczbowy udostępnia swoje granice jako stałe:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine($"byte:  {byte.MinValue} to {byte.MaxValue}");
        Console.WriteLine($"short: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int:   {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long:  {long.MinValue} to {long.MaxValue}");
        Console.WriteLine($"decimal max: {decimal.MaxValue}");
        Console.WriteLine($"double max:  {double.MaxValue:E3}");
        Console.WriteLine($"sizes: int {sizeof(int)}, long {sizeof(long)}, double {sizeof(double)}, char {sizeof(char)}");

        int hex = 0xFF;             // hexadecimal
        int bits = 0b1010_0001;     // binary (C# 7)
        long big = 3_000_000_000;   // digit separators (C# 7)
        Console.WriteLine($"{hex} {bits} {big}");
    }
}

Wynik:

byte:  0 to 255
short: -32768 to 32767
int:   -2147483648 to 2147483647
long:  -9223372036854775808 to 9223372036854775807
decimal max: 79228162514264337593543950335
double max:  1.798E+308
sizes: int 4, long 8, double 8, char 2
255 161 3000000000

W praktyce większość kodu używa czterech z nich: int do liczników i indeksów, long do identyfikatorów i dużych sum, double do pomiarów i obliczeń matematycznych oraz decimal do pieniędzy.

decimal a double

double (i float) przechowują liczby w systemie dwójkowym. Większość ułamków dziesiętnych, w tym 0.1, nie ma dokładnej postaci binarnej, więc są zapisywane jako najbliższa możliwa wartość, a drobne błędy się kumulują. decimal przechowuje liczbę całkowitą w systemie dziesiętnym plus skalę, więc 0.1 to dokładnie 0.1.

using System;

class Program
{
    static void Main()
    {
        double a = 0.1 + 0.2;
        decimal b = 0.1m + 0.2m;
        Console.WriteLine(a == 0.3);          // False
        Console.WriteLine(b == 0.3m);         // True
        Console.WriteLine(a.ToString("G17")); // 17 significant digits
        Console.WriteLine(b);

        double dsum = 0;
        decimal msum = 0;
        for (int i = 0; i < 10; i++)
        {
            dsum += 0.1;
            msum += 0.1m;
        }
        Console.WriteLine($"double sum == 1.0: {dsum == 1.0}");
        Console.WriteLine($"decimal sum == 1.0: {msum == 1.0m}");

        decimal price = 19.99m;
        int quantity = 3;
        decimal total = price * quantity;
        Console.WriteLine($"Total: {total}");
        Console.WriteLine($"Split three ways: {total / 3}");
    }
}

Wynik:

False
True
0.30000000000000004
0.3
double sum == 1.0: False
decimal sum == 1.0: True
Total: 59.97
Split three ways: 19.99

Używaj decimal do pieniędzy, cen, podatków i wszystkiego, co człowiek zsumuje ręcznie i porówna. Zachowuje końcowe zera z danych wejściowych (1.50m wypisuje się jako 1.50) i ma od 28 do 29 cyfr znaczących.

Używaj double do pomiarów fizycznych, statystyki, geometrii i gier. Jest kilka razy szybszy, zajmuje połowę pamięci, a jego zakres jest ogromny. Nigdy nie porównuj dwóch obliczonych wartości double przez ==; porównaj różnicę z tolerancją: Math.Abs(x - y) < 1e-9.

decimal nie jest magiczny: 1m / 3m to nadal 0.3333333333333333333333333333, a arytmetyka na double nie rzuca wyjątku przy dzieleniu przez zero (daje nieskończoność albo NaN dla 0.0 / 0.0), podczas gdy dzielenie przez zero na decimal i liczbach całkowitych rzuca DivideByZeroException.

Przepełnienie liczb całkowitych i checked

Arytmetyka całkowita, która wychodzi poza zakres typu, domyślnie zawija się, po cichu. Kompilator wyłapuje przepełnienie w wyrażeniach stałych, ale nie wtedy, gdy wartości pochodzą ze zmiennych:

using System;

class Program
{
    static void Main()
    {
        int max = int.MaxValue;
        int wrapped = max + 1;           // no error: wraps around
        Console.WriteLine(wrapped);

        try
        {
            int safe = checked(max + 1); // throws instead of wrapping
            Console.WriteLine(safe);
        }
        catch (OverflowException)
        {
            Console.WriteLine("OverflowException");
        }

        long views = 3_000_000_000;
        int truncated = unchecked((int)views); // explicit narrowing keeps low 32 bits
        Console.WriteLine(truncated);

        long total = (long)max + 1;       // widen first to get the right answer
        Console.WriteLine(total);
    }
}

Wynik:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) albo blok checked { ... } zamienia przepełnienie w OverflowException. Można to też włączyć dla całego projektu przez <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. Zapis int x = int.MaxValue + 1; ze stałymi to błąd kompilacji (CS0220), bo kompilator widzi przepełnienie.

Ostatnia linia pokazuje rozwiązanie większości błędów przepełnienia: konwertuj na szerszy typ przed obliczeniem. (long)(max + 1) byłoby błędne, bo dodawanie zawinęło się, zanim zadziałało rzutowanie.

Typy wartościowe i referencyjne

Każdy typ w C# jest albo wartościowy, albo referencyjny, a ta różnica decyduje o tym, co robi przypisanie.

• Typy wartościowe: wszystkie typy liczbowe, bool, char, DateTime, enumy i każda struct. Zmienna zawiera dane; przypisanie je kopiuje.
• Typy referencyjne: string, tablice, object i każda class. Zmienna zawiera referencję do obiektu; przypisanie kopiuje referencję, więc obie zmienne widzą ten sam obiekt.

using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = a;      // copy of the value
        b = 99;
        Console.WriteLine($"a={a} b={b}");

        int[] first = { 1, 2, 3 };
        int[] second = first;   // copy of the reference
        second[0] = 99;
        Console.WriteLine($"first[0]={first[0]}");

        string s1 = "cat";
        string s2 = s1;
        s2 += "s";              // strings are immutable: s2 now refers to a new string
        Console.WriteLine($"s1={s1} s2={s2}");
    }
}

Wynik:

a=10 b=99
first[0]=99
s1=cat s2=cats

string to typ referencyjny, który w praktyce zachowuje się jak wartość: jest niemodyfikowalny, a == porównuje tekst, a nie referencje. Więcej o typach wartościowych definiowanych przez użytkownika w strukturach.

char i bool

char to jedna jednostka kodowa UTF-16, zapisywana w pojedynczych cudzysłowach. Pod spodem to typ liczbowy, więc konwertuje się na int i obsługuje arytmetykę:

using System;

class Program
{
    static void Main()
    {
        char grade = 'B';
        Console.WriteLine((int)grade);           // 66
        Console.WriteLine((char)(grade + 1));    // C
        Console.WriteLine(char.IsLetter(grade));
        Console.WriteLine(char.IsDigit('7'));
        Console.WriteLine('7' - '0');             // digit char to its value
        Console.WriteLine(char.ToLower(grade));

        bool isOpen = true;
        bool hasStock = false;
        Console.WriteLine(isOpen && !hasStock);
    }
}

Wynik:

66
C
True
True
7
b
True

bool ma dokładnie dwie wartości i nie konwertuje się na liczby ani z liczb: if (count) to błąd kompilacji, a nie test na wartość różną od zera. Napisz if (count != 0). Znaki spoza Basic Multilingual Plane, takie jak większość emotek, zajmują dwie wartości char (parę zastępczą), więc Length w string liczy jednostki UTF-16, a nie widoczne znaki.

Wartości domyślne

Pola, elementy tablic i default(T) dostają wartość domyślną typu: zero dla liczb, false dla bool, '\0' dla char i null dla typów referencyjnych. Zmienne lokalne nie dostają wartości domyślnej i trzeba je przypisać przed użyciem.

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine(default(int));
        Console.WriteLine(default(decimal));
        Console.WriteLine(default(bool));
        Console.WriteLine(default(string) == null);
        Console.WriteLine(default(DateTime).ToString("yyyy-MM-dd"));

        var counts = new int[3];
        Console.WriteLine(string.Join(",", counts));
    }
}

Wynik:

0
0
False
True
0001-01-01
0,0,0

Od C# 7.1 można pisać literał default bez typu, gdy kompilator potrafi go wywnioskować (int x = default;). Typ wartościowy nie może być null i do tego służy int? (typ wartościowy nullable); zobacz typy nullable.

Liczby całkowite o rozmiarze natywnym i duże liczby całkowite

Dla szczególnych przypadków istnieją jeszcze dwa typy liczbowe. nint i nuint (C# 9) to liczby całkowite o rozmiarze wskaźnika, 32 lub 64 bity w zależności od platformy, używane przy współpracy z kodem natywnym i w kodzie niskopoziomowym. System.Numerics.BigInteger przechowuje liczby całkowite dowolnej wielkości kosztem szybkości:

using System.Numerics;
BigInteger factorial = 1;
for (int i = 2; i <= 30; i++) factorial *= i;
// 265252859812191058636308480000000