אופרטורים ב-C#: חשבון, מודולו, לוגיקה, סיביות וקדימות

אופרטור מקבל אופרנד אחד, שניים או שלושה ומפיק ערך: a + b, !done, x ?? fallback. האופרטורים של C# קרובים לאלה של C, Java ו-JavaScript, אבל כמה מהם מתנהגים בדרכים שמפתיעות מתחילים, ובראשם חילוק שלמים והסימן של %.

אופרטורים אריתמטיים

+, -, *, / ו-% עובדים על כל טיפוס מספרי. הטיפוס של התוצאה נקבע לפי האופרנדים: שני ערכי int מפיקים int, ו-int עם double מפיקים double.

using System;

class Program
{
    static void Main()
    {
        int apples = 17, boxes = 5;

        Console.WriteLine(apples + boxes);   // 22
        Console.WriteLine(apples - boxes);   // 12
        Console.WriteLine(apples * boxes);   // 85
        Console.WriteLine(apples / boxes);   // 3: integer division
        Console.WriteLine(apples % boxes);   // 2: remainder

        Console.WriteLine(apples / 5.0);            // 3.4
        Console.WriteLine((double)apples / boxes);  // 3.4
        Console.WriteLine((double)(apples / boxes)); // 3: divided first, then converted
        Console.WriteLine(apples / 5m);             // 3.4 as decimal
    }
}

פלט:

22
12
85
3
2
3.4
3.4
3
3.4

חילוק שלמים מקטם לכיוון אפס. 17 / 5 הוא 3 ו--17 / 5 הוא -3. זה גורם לבאג נפוץ מאוד: int percent = done / total * 100; הוא 0 בכל פעם ש-done < total, כי done / total כבר 0. הכפילו קודם (done * 100 / total) או חלקו כ-double.

חילוק של מספר שלם או decimal באפס זורק DivideByZeroException. חילוק של double באפס לא זורק; הוא מפיק אינסוף, או NaN עבור 0.0 / 0.0:

using System;

class Program
{
    static void Main()
    {
        double ratio = 5.0 / 0;
        double undefined = 0.0 / 0;
        Console.WriteLine(double.IsPositiveInfinity(ratio));
        Console.WriteLine(double.IsNaN(undefined));
        Console.WriteLine(undefined == undefined);   // NaN never equals anything

        int zero = 0;
        try
        {
            Console.WriteLine(10 / zero);
        }
        catch (DivideByZeroException)
        {
            Console.WriteLine("DivideByZeroException");
        }
    }
}

פלט:

True
True
False
DivideByZeroException

אופרטור המודולו ומספרים שליליים

% מחזיר את השארית של החילוק, והתוצאה שלו מקבלת את הסימן של האופרנד השמאלי. זה שונה מ-Python ומה-"mod" המתמטי, שתמיד אינם שליליים כשהמחלק חיובי:

using System;

class Program
{
    static int Mod(int a, int n)
    {
        return ((a % n) + n) % n;   // always in 0..n-1
    }

    static void Main()
    {
        Console.WriteLine(7 % 3);     // 1
        Console.WriteLine(-7 % 3);    // -1
        Console.WriteLine(7 % -3);    // 1
        Console.WriteLine(Mod(-7, 3)); // 2

        // Common uses:
        int n = 42;
        Console.WriteLine(n % 2 == 0 ? "even" : "odd");

        int totalSeconds = 3725;
        Console.WriteLine($"{totalSeconds / 60} min {totalSeconds % 60} s");

        string[] days = { "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun" };
        int today = 5, offset = -9;
        Console.WriteLine(days[Mod(today + offset, 7)]);  // wraps backwards safely

        Console.WriteLine(7.5 % 2);   // works on double: 1.5
    }
}

פלט:

1
-1
1
2
even
62 min 5 s
Thu
1.5

השתמשו בפונקציית העזר Mod בכל פעם שהצד השמאלי יכול להיות שלילי והתוצאה היא אינדקס: days[(today + offset) % 7] היה זורק IndexOutOfRangeException עבור סכום שלילי. בבדיקת מספרים אי-זוגיים יש אותה מלכודת: n % 2 == 1 הוא false עבור מספרים אי-זוגיים שליליים; בדקו n % 2 != 0.

השמה, השמה מורכבת והגדלה

= מבצע השמה. הצורות המורכבות +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= משלבות פעולה עם השמה. ++ ו--- מוסיפים או מחסירים 1, ויש להם צורת תחילית וצורת סופית שנבדלות בערך שהן מחזירות:

using System;

class Program
{
    static void Main()
    {
        int stock = 10;
        stock -= 3;          // stock = stock - 3
        stock *= 2;          // stock = stock * 2
        Console.WriteLine(stock);   // 14

        string log = "start";
        log += ", step";     // += concatenates strings
        Console.WriteLine(log);

        int i = 5;
        int a = i++;   // a gets 5, then i becomes 6
        int b = ++i;   // i becomes 7, then b gets 7
        Console.WriteLine($"a={a} b={b} i={i}");

        byte level = 250;
        level += 10;   // compiles: compound assignment casts back to byte (and wraps)
        Console.WriteLine(level);
    }
}

פלט:

14
start, step
a=5 b=7 i=7
4

המקרה של byte מראה מוזרות: level = level + 10; לא מתקמפל, כי byte + int הוא int, אבל level += 10; כן מתקמפל, כי השמה מורכבת כוללת המרה מרומזת חזרה לטיפוס של המשתנה. ההמרה הזו מתגלגלת בגלישה (250 + 10 הופך ל-4).

אופרטורי השוואה ואופרטורים לוגיים

אופרטורי השוואה (==, !=, <, >, <=, >=) מחזירים bool. במחרוזות, == משווה את הטקסט, לא את ההפניות. האופרטורים הלוגיים הם ! (לא), && (וגם), || (או) ו-^ (או בלעדי).

using System;

class User
{
    public string Name;
    public bool IsActive;
}

class Program
{
    static bool Check(string label, bool result)
    {
        Console.WriteLine($"  evaluated {label}");
        return result;
    }

    static void Main()
    {
        Console.WriteLine(3 < 5 && "abc" == "ab" + "c");

        User user = null;
        // Safe: && stops at the first false, so user.IsActive is never read.
        if (user != null && user.IsActive)
            Console.WriteLine("active");
        else
            Console.WriteLine("no active user");

        Console.WriteLine("with ||:");
        bool r1 = Check("A", true) || Check("B", true);   // B is skipped

        Console.WriteLine("with |:");
        bool r2 = Check("A", true) | Check("B", true);    // both run

        Console.WriteLine(true ^ false);   // exactly one is true
    }
}

פלט:

True
no active user
with ||:
  evaluated A
with |:
  evaluated A
  evaluated B
True

&& ו-|| מקצרים: האופרנד הימני רץ רק כשהוא יכול לשנות את התוצאה. זה מה שהופך את user != null && user.IsActive לבטוח. & ו-| בודדים על ערכים בוליאניים תמיד מחשבים את שני הצדדים, וזה רק לעיתים רחוקות מה שרוצים בתנאי.

אופרטורי סיביות והזזה

על טיפוסים שלמים, &, |, ^ ו-~ פועלים על סיביות בודדות, ו-<< ו->> מזיזים אותן. משתמשים בהם לדגלים, למסכות, לגיבוב ולפרוטוקולים ברמה נמוכה:

using System;

class Program
{
    const int Read = 1;     // 0001
    const int Write = 2;    // 0010
    const int Delete = 4;   // 0100

    static void Main()
    {
        int permissions = Read | Write;              // set two flags
        Console.WriteLine(permissions);                        // 3
        Console.WriteLine((permissions & Write) != 0);          // has Write?
        Console.WriteLine((permissions & Delete) != 0);         // has Delete?

        permissions |= Delete;                       // add a flag
        permissions &= ~Write;                       // remove a flag
        Console.WriteLine(Convert.ToString(permissions, 2));    // 101

        Console.WriteLine(1 << 10);                  // 1024
        Console.WriteLine(1000 >> 3);                // 125 (divide by 8)
        Console.WriteLine(6 ^ 3);                    // 110 xor 011 = 101 = 5
        Console.WriteLine(~0);                       // all bits set: -1
    }
}

פלט:

3
True
False
101
1024
125
5
-1

לקבוצות דגלים עם שמות, enum עם התכונה [Flags] ברור יותר מקבועים שלמים, ו-HasFlag קריא יותר ממסכה. C# 11 הוסיפה את >>>, הזזה ימינה ללא סימן שממלאת באפסים גם במספרים שליליים.

אופרטורי null

יש שלושה אופרטורים לעבודה עם ערכים שעשויים להיות null:

using System;

class Program
{
    static void Main()
    {
        string nickname = null;
        string display = nickname ?? "Guest";         // fallback when null
        Console.WriteLine(display);

        Console.WriteLine(nickname?.Length);          // null, not an exception
        int length = nickname?.Length ?? 0;
        Console.WriteLine(length);

        int? discount = null;
        Console.WriteLine(discount ?? 5);
    }
}

פלט:

Guest

0
5

a ?? b מחזיר את a אלא אם הוא null, ואז את b. a?.Member מחזיר null במקום לזרוק חריגה כש-a הוא null. C# 8 הוסיפה את a ??= b, שמציב את b ב-a רק כש-a הוא null. הם מוסברים לעומק בדף על טיפוסי nullable.

קדימות אופרטורים

כשביטוי משלב כמה אופרטורים, שורות גבוהות יותר נקשרות חזק יותר. אופרטורים באותה שורה מקובצים משמאל לימין, חוץ מהשמה, ?? ו-?:, שמקובצים מימין לשמאל. (האופרנדים עצמם תמיד מחושבים משמאל לימין.)

שתי השלכות שכדאי להכיר: a + b * c מכפיל קודם, ו-x & mask == 0 משווה קודם (== נקשר חזק יותר מ-&), כך שמשמעותו x & (mask == 0) והוא לא מתקמפל עם מספרים שלמים. כתבו (x & mask) == 0. סוגריים לא עולים כלום והופכים את הכוונה לברורה.

העמסת אופרטורים

הטיפוסים שלכם יכולים להגדיר מה משמעות האופרטורים. כך decimal, DateTime ו-TimeSpan תומכים ב-+ וב-<:

using System;

struct Money
{
    public readonly decimal Amount;
    public Money(decimal amount) { Amount = amount; }

    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public static Money operator *(Money a, int n) => new Money(a.Amount * n);
    public static bool operator >(Money a, Money b) => a.Amount > b.Amount;
    public static bool operator <(Money a, Money b) => a.Amount < b.Amount;

    public override string ToString() => Amount.ToString("F2");
}

class Program
{
    static void Main()
    {
        var shirt = new Money(19.99m);
        var socks = new Money(4.50m);
        Money total = shirt + socks * 3;
        Console.WriteLine(total);
        Console.WriteLine(total > new Money(30m));
    }
}

פלט:

33.49
True

אופרטורים חייבים להיות public static, וחלקם מגיעים בזוגות מחייבים: הגדרה של < מחייבת את >, ו-== מחייב את !=. כש-== מוגדר, הקומפיילר גם מזהיר עד שתדרסו את Equals ואת GetHashCode בהתאם. העמיסו אופרטורים רק כשהמשמעות ברורה, כמו במספרים, וקטורים וכסף.