Operatory w C#: arytmetyczne, modulo, logiczne, bitowe i priorytety

Operator przyjmuje jeden, dwa lub trzy operandy i daje wartość: a + b, !done, x ?? fallback. Operatory C# są bliskie tym z C, Javy i JavaScriptu, ale kilka zachowuje się w sposób zaskakujący dla początkujących, przede wszystkim dzielenie całkowite i znak %.

Operatory arytmetyczne

+, -, *, / i % działają na każdym typie liczbowym. Typ wyniku zależy od operandów: dwie wartości int dają int, a int i double dają 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
    }
}

Wynik:

22
12
85
3
2
3.4
3.4
3
3.4

Dzielenie całkowite obcina w stronę zera. 17 / 5 daje 3, a -17 / 5 daje -3. To źródło bardzo częstego błędu: int percent = done / total * 100; daje 0 za każdym razem, gdy done < total, bo done / total już jest 0. Najpierw pomnóż (done * 100 / total) albo dziel jako double.

Dzielenie liczby całkowitej lub decimal przez zero rzuca DivideByZeroException. Dzielenie double przez zero nie rzuca wyjątku; daje nieskończoność albo NaN dla 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");
        }
    }
}

Wynik:

True
True
False
DivideByZeroException

Operator modulo i liczby ujemne

% zwraca resztę z dzielenia, a jego wynik ma znak lewego operandu. To różni go od Pythona i od matematycznego "mod", które przy dodatnim dzielniku są zawsze nieujemne:

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

Wynik:

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

Używaj funkcji pomocniczej Mod zawsze, gdy lewa strona może być ujemna, a wynik jest indeksem: days[(today + offset) % 7] rzuciłoby IndexOutOfRangeException dla ujemnej sumy. Sprawdzanie liczb nieparzystych ma tę samą pułapkę: n % 2 == 1 daje false dla ujemnych liczb nieparzystych; sprawdzaj n % 2 != 0.

Przypisanie, przypisanie złożone i inkrementacja

= przypisuje. Formy złożone +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= łączą operację z przypisaniem. ++ i -- dodają lub odejmują 1 i występują w formie przedrostkowej i przyrostkowej, które różnią się zwracaną wartością:

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

Wynik:

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

Przypadek byte pokazuje pewne dziwactwo: level = level + 10; się nie kompiluje, bo byte + int to int, ale level += 10; się kompiluje, bo przypisanie złożone zawiera niejawne rzutowanie z powrotem na typ zmiennej. To rzutowanie zawija wartość przy przepełnieniu (250 + 10 daje 4).

Operatory porównania i logiczne

Operatory porównania (==, !=, <, >, <=, >=) zwracają bool. Dla stringów == porównuje tekst, a nie referencje. Operatory logiczne to ! (nie), && (i), || (lub) i ^ (alternatywa wykluczająca).

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

Wynik:

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

&& i || skracają obliczenia: prawy operand wykonuje się tylko wtedy, gdy może zmienić wynik. Właśnie dlatego user != null && user.IsActive jest bezpieczne. Pojedyncze & i | na wartościach logicznych zawsze obliczają obie strony, a w warunku rzadko tego chcesz.

Operatory bitowe i przesunięcia

Na typach całkowitych &, |, ^ i ~ działają na pojedynczych bitach, a << i >> je przesuwają. Używa się ich do flag, masek, haszowania i niskopoziomowych protokołów:

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

Wynik:

3
True
False
101
1024
125
5
-1

Dla nazwanych zestawów flag enum z atrybutem [Flags] jest czytelniejszy niż stałe całkowite, a HasFlag czyta się lepiej niż maskę. C# 11 dodał >>>, przesunięcie w prawo bez znaku, które wypełnia zerami nawet liczby ujemne.

Operatory null

Do pracy z wartościami, które mogą być null, służą trzy operatory:

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

Wynik:

Guest

0
5

a ?? b zwraca a, chyba że jest null, wtedy b. a?.Member zwraca null zamiast rzucać wyjątek, gdy a jest null. C# 8 dodał a ??= b, które przypisuje b do a tylko wtedy, gdy a jest null. Szczegółowo opisują je typy nullable.

Priorytet operatorów

Gdy wyrażenie łączy operatory, wyższe wiersze wiążą silniej. Operatory z tego samego wiersza grupują się od lewej do prawej, z wyjątkiem przypisania, ?? i ?:, które grupują się od prawej do lewej. (Same operandy są zawsze obliczane od lewej do prawej.)

Dwie konsekwencje warte poznania: a + b * c najpierw mnoży, a x & mask == 0 najpierw porównuje (== wiąże silniej niż &), więc oznacza x & (mask == 0) i nie kompiluje się dla liczb całkowitych. Pisz (x & mask) == 0. Nawiasy nic nie kosztują, a intencja staje się oczywista.

Przeciążanie operatorów

Twoje własne typy mogą definiować znaczenie operatorów. W ten sposób decimal, DateTime i TimeSpan obsługują + i <:

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

Wynik:

33.49
True

Operatory muszą być public static, a niektóre występują w wymaganych parach: zdefiniowanie < wymaga >, a == wymaga !=. Gdy == jest zdefiniowane, kompilator ostrzega też, dopóki nie nadpiszesz pasujących Equals i GetHashCode. Przeciążaj operatory tylko tam, gdzie ich znaczenie jest oczywiste, jak przy liczbach, wektorach i pieniądzach.