טיפוסי נתונים ב-C#: int, double, decimal, char, bool והטווחים שלהם

C# היא שפה עם טיפוסים סטטיים: לכל משתנה, שדה וביטוי יש טיפוס שידוע בזמן קומפילציה. לשפה יש קבוצה של טיפוסים מובנים עם מילות מפתח משלהם (int, double, string...). כל מילת מפתח היא כינוי לטיפוס ב-namespace System, כך ש-int ו-System.Int32 הם אותו טיפוס, ו-string ו-System.String הם אותו טיפוס.

הטיפוסים המובנים

ליטרל של מספר שלם בלי סיומת הוא int, או הראשון מבין uint, long ו-ulong שיכול להכיל אותו אם הוא גדול מדי ל-int, וליטרל עם נקודה עשרונית הוא double. זו הסיבה ש-float f = 2.5; ו-decimal d = 2.5; לא עוברים קומפילציה: הליטרל הוא double, ואין המרה מרומזת מ-double ל-float או ל-decimal. הוסיפו את הסיומת: 2.5f, 2.5m.

כל טיפוס מספרי חושף את הגבולות שלו כקבועים:

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

פלט:

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

בפועל רוב הקוד משתמש בארבעה מהם: int לספירות ולאינדקסים, long למזהים ולסכומים גדולים, double למדידות ולמתמטיקה, ו-decimal לכסף.

decimal מול double

double (ו-float) מאחסנים מספרים בבינארי. לרוב השברים העשרוניים, כולל 0.1, אין צורה בינארית מדויקת, ולכן הם נשמרים כערך הקרוב ביותר שניתן לייצג, ושגיאות קטנות מצטברות. decimal מאחסן מספר שלם בבסיס 10 ועוד קנה מידה, כך ש-0.1 הוא בדיוק 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}");
    }
}

פלט:

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

השתמשו ב-decimal לכסף, למחירים, למס ולכל דבר שאדם יחבר ביד וישווה. הוא שומר על אפסים בסוף מהקלט שלו (1.50m מודפס כ-1.50) ויש לו 28 עד 29 ספרות משמעותיות.

השתמשו ב-double למדידות פיזיקליות, לסטטיסטיקה, לגאומטריה ולמשחקים. הוא מהיר פי כמה, משתמש בחצי מהזיכרון, והטווח שלו עצום. אף פעם אל תשוו שני doubles מחושבים עם ==; השוו את ההפרש מול סף סבילות: Math.Abs(x - y) < 1e-9.

decimal הוא לא קסם: 1m / 3m הוא עדיין 0.3333333333333333333333333333, וחשבון עם double לא זורק בחלוקה באפס (הוא מפיק אינסוף, או NaN עבור 0.0 / 0.0), בעוד שחלוקה באפס של decimal ושל מספרים שלמים זורקת DivideByZeroException.

גלישה של מספרים שלמים ו-checked

חשבון של מספרים שלמים שחורג מהטווח של הטיפוס גולש מסביב כברירת מחדל, בשקט. הקומפיילר תופס גלישה בביטויים קבועים, אבל לא כשהערכים מגיעים ממשתנים:

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

פלט:

-2147483648
OverflowException
-1294967296
2147483648

checked(...) או בלוק checked { ... } הופכים גלישה ל-OverflowException. אפשר גם להפעיל את זה לכל הפרויקט עם <CheckForOverflowUnderflow>true</CheckForOverflowUnderflow>. כתיבה של int x = int.MaxValue + 1; עם קבועים היא שגיאת קומפילציה (CS0220), כי הקומפיילר יכול לראות את הגלישה.

השורה האחרונה מראה את התיקון לרוב באגי הגלישה: המירו לטיפוס רחב יותר לפני החישוב. (long)(max + 1) היה שגוי, כי החיבור כבר גלש כשההמרה רצה.

טיפוסי ערך וטיפוסי הפניה

כל טיפוס ב-C# הוא טיפוס ערך או טיפוס הפניה, וההבדל קובע מה הצבה עושה.

• טיפוסי ערך: כל הטיפוסים המספריים, bool, char, DateTime, enums, וכל struct. המשתנה מכיל את הנתונים; הצבה מעתיקה אותם.
• טיפוסי הפניה: string, מערכים, object, וכל class. המשתנה מכיל הפניה לאובייקט; הצבה מעתיקה את ההפניה, כך ששני המשתנים רואים את אותו אובייקט.

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

פלט:

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

string הוא טיפוס הפניה שמתנהג בפועל כמו ערך: הוא בלתי ניתן לשינוי, ו-== משווה את הטקסט, לא את ההפניות. עוד על טיפוסי ערך שהמשתמש מגדיר ב-structs.

char ו-bool

char הוא יחידת קוד UTF-16 אחת, שנכתבת בגרשיים בודדים. מתחת לפני השטח הוא טיפוס מספרי, ולכן הוא מומר ל-int ותומך בחשבון:

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

פלט:

66
C
True
True
7
b
True

ל-bool יש בדיוק שני ערכים, והוא לא מומר ממספרים או אליהם: if (count) היא שגיאת קומפילציה, לא בדיקה של שונה מאפס. כתבו if (count != 0). תווים מחוץ ל-Basic Multilingual Plane, כמו רוב האימוג'י, תופסים שני ערכי char (surrogate pair), כך שה-Length של string סופר יחידות UTF-16, לא תווים נראים.

ערכי ברירת מחדל

שדות, איברי מערך ו-default(T) מקבלים את ערך ברירת המחדל של הטיפוס: אפס למספרים, false ל-bool, '\0' ל-char, ו-null לטיפוסי הפניה. משתנים מקומיים לא מקבלים ברירת מחדל, וחייבים להציב להם ערך לפני השימוש.

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

פלט:

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

מאז C# 7.1 אפשר לכתוב את הליטרל default בלי הטיפוס כשהקומפיילר יכול להסיק אותו (int x = default;). טיפוס ערך לא יכול להיות null, ובשביל זה קיים int? (nullable value type); ראו nullable types.

מספרים שלמים בגודל נייטיב ומספרים גדולים

קיימים עוד שני טיפוסים מספריים למקרים מיוחדים. nint ו-nuint (C# 9) הם מספרים שלמים בגודל של מצביע, 32 או 64 ביט לפי הפלטפורמה, ומשמשים ב-interop ובקוד ברמה נמוכה. System.Numerics.BigInteger מחזיק מספרים שלמים בכל גודל, במחיר של מהירות:

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