Operator C#: Aritmetika, Modulo, Logika, Bitwise dan Prioritas

Operator menerima satu, dua atau tiga operand lalu menghasilkan sebuah nilai: a + b, !done, x ?? fallback. Operator di C# mirip dengan operator di C, Java dan JavaScript, tapi beberapa di antaranya berperilaku dengan cara yang mengejutkan pemula, terutama pembagian bilangan bulat dan tanda hasil %.

Operator aritmetika

+, -, *, / dan % bekerja pada setiap tipe numerik. Tipe hasilnya mengikuti operand-nya: dua nilai int menghasilkan int, sedangkan int dan double menghasilkan 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
    }
}

Output:

22
12
85
3
2
3.4
3.4
3
3.4

Pembagian bilangan bulat dibulatkan ke arah nol. 17 / 5 hasilnya 3 dan -17 / 5 hasilnya -3. Ini menyebabkan bug yang sangat umum: int percent = done / total * 100; bernilai 0 setiap kali done < total, karena done / total sudah bernilai 0. Kalikan dulu (done * 100 / total) atau bagi sebagai double.

Membagi bilangan bulat atau decimal dengan nol melempar DivideByZeroException. Membagi double dengan nol tidak melempar exception; hasilnya tak hingga, atau NaN untuk 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");
        }
    }
}

Output:

True
True
False
DivideByZeroException

Operator modulo dan bilangan negatif

% mengembalikan sisa pembagian, dan hasilnya mengikuti tanda operand kiri. Ini berbeda dari Python dan dari "mod" dalam matematika, yang selalu tidak negatif untuk pembagi positif:

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

Output:

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

Pakai fungsi bantu Mod setiap kali sisi kirinya bisa negatif dan hasilnya dipakai sebagai indeks: days[(today + offset) % 7] akan melempar IndexOutOfRangeException kalau jumlahnya negatif. Memeriksa bilangan ganjil punya jebakan yang sama: n % 2 == 1 bernilai false untuk bilangan ganjil negatif; periksa dengan n % 2 != 0.

Assignment, compound assignment dan increment

= memberikan nilai. Bentuk compound +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= menggabungkan sebuah operasi dengan pemberian nilai. ++ dan -- menambah atau mengurangi 1, dan tersedia dalam bentuk prefix dan postfix yang berbeda pada nilai yang dikembalikannya:

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

Output:

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

Kasus byte memperlihatkan sebuah keanehan: level = level + 10; tidak bisa di-compile, karena byte + int menghasilkan int, tapi level += 10; bisa, karena compound assignment menyertakan cast implisit kembali ke tipe variabelnya. Cast itu berputar balik saat terjadi overflow (250 + 10 menjadi 4).

Operator perbandingan dan logika

Operator perbandingan (==, !=, <, >, <=, >=) mengembalikan bool. Untuk string, == membandingkan teksnya, bukan referensinya. Operator logikanya adalah ! (tidak), && (dan), || (atau) dan ^ (eksklusif atau).

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

Output:

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

&& dan || melakukan short-circuit: operand kanan hanya dijalankan saat bisa mengubah hasilnya. Itulah yang membuat user != null && user.IsActive aman. & dan | tunggal pada boolean selalu mengevaluasi kedua sisinya, yang jarang sekali kamu inginkan dalam sebuah kondisi.

Operator bitwise dan shift

Pada tipe bilangan bulat, &, |, ^ dan ~ bekerja pada bit satu per satu, sedangkan << dan >> menggesernya. Operator-operator ini dipakai untuk flag, mask, hashing dan protokol tingkat rendah:

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

Output:

3
True
False
101
1024
125
5
-1

Untuk kumpulan flag yang bernama, enum dengan atribut [Flags] lebih jelas daripada konstanta bilangan bulat, dan HasFlag lebih enak dibaca daripada sebuah mask. C# 11 menambahkan >>>, yaitu right shift tanpa tanda yang mengisi dengan nol bahkan untuk bilangan negatif.

Operator null

Ada tiga operator untuk bekerja dengan nilai yang mungkin 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);
    }
}

Output:

Guest

0
5

a ?? b mengembalikan a kecuali nilainya null, dan kalau null mengembalikan b. a?.Member mengembalikan null alih-alih melempar exception saat a bernilai null. C# 8 menambahkan a ??= b, yang memberikan b ke a hanya saat a bernilai null. Semuanya dibahas secara mendalam di nullable type.

Prioritas operator

Saat sebuah ekspresi mencampur beberapa operator, baris yang lebih tinggi mengikat lebih kuat. Operator di baris yang sama dikelompokkan dari kiri ke kanan, kecuali assignment, ?? dan ?:, yang dikelompokkan dari kanan ke kiri. (Operand-nya sendiri selalu dievaluasi dari kiri ke kanan.)

Ada dua akibat yang perlu kamu tahu: a + b * c melakukan perkalian terlebih dahulu, dan x & mask == 0 melakukan perbandingan terlebih dahulu (== mengikat lebih kuat daripada &), jadi artinya x & (mask == 0) dan tidak bisa di-compile untuk bilangan bulat. Tulis (x & mask) == 0. Tanda kurung tidak ada ruginya dan membuat maksudmu jelas.

Operator overloading

Tipe buatanmu sendiri bisa mendefinisikan arti sebuah operator. Dengan cara inilah decimal, DateTime dan TimeSpan mendukung + dan <:

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

Output:

33.49
True

Operator harus public static, dan beberapa operator harus dibuat berpasangan: mendefinisikan < mewajibkan >, dan == mewajibkan !=. Setelah == didefinisikan, compiler juga memberi warning sampai kamu meng-override Equals dan GetHashCode agar sesuai. Lakukan overload operator hanya di tempat artinya sudah jelas, seperti pada angka, vektor dan uang.