Toán tử trong C#: số học, chia lấy dư, logic, bit và độ ưu tiên

Toán tử (operator) nhận một, hai hoặc ba toán hạng và tạo ra một giá trị: a + b, !done, x ?? fallback. Các toán tử của C# gần giống C, Java và JavaScript, nhưng có vài toán tử hoạt động theo cách khiến người mới bất ngờ, trên hết là phép chia số nguyên và dấu của %.

Toán tử số học

+, -, *, / và % dùng được với mọi kiểu số. Kiểu của kết quả đi theo các toán hạng: hai giá trị int cho ra int, một int và một double cho ra 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
    }
}

Đầu ra:

22
12
85
3
2
3.4
3.4
3
3.4

Phép chia số nguyên làm tròn về phía 0. 17 / 5 bằng 3 và -17 / 5 bằng -3. Điều này gây ra một bug rất phổ biến: int percent = done / total * 100; luôn bằng 0 khi done < total, vì done / total đã là 0. Hãy nhân trước (done * 100 / total) hoặc chia theo kiểu double.

Chia một số nguyên hoặc decimal cho 0 sẽ ném DivideByZeroException. Chia một double cho 0 thì không ném ngoại lệ; kết quả là vô cực, hoặc NaN với 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");
        }
    }
}

Đầu ra:

True
True
False
DivideByZeroException

Toán tử chia lấy dư và số âm

% trả về phần dư của phép chia, và kết quả mang dấu của toán hạng bên trái. Điều này khác với Python và với phép "mod" trong toán học, vốn luôn không âm khi số chia dương:

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

Đầu ra:

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

Hãy dùng hàm hỗ trợ Mod mỗi khi vế trái có thể âm và kết quả là một chỉ số: days[(today + offset) % 7] sẽ ném IndexOutOfRangeException khi tổng là số âm. Kiểm tra số lẻ cũng có cái bẫy tương tự: n % 2 == 1 là false với số lẻ âm; hãy kiểm tra n % 2 != 0.

Phép gán, gán kết hợp và tăng giảm

= dùng để gán. Các dạng kết hợp +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= gộp một phép toán với phép gán. ++ và -- cộng hoặc trừ 1, và có dạng tiền tố lẫn hậu tố, khác nhau ở giá trị mà chúng trả về:

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

Đầu ra:

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

Trường hợp byte cho thấy một điểm lạ: level = level + 10; không biên dịch được, vì byte + int là một int, nhưng level += 10; thì được, vì phép gán kết hợp có sẵn một phép ép kiểu ngầm về kiểu của biến. Phép ép kiểu đó quay vòng khi tràn số (250 + 10 thành 4).

Toán tử so sánh và logic

Các toán tử so sánh (==, !=, <, >, <=, >=) trả về một bool. Với chuỗi, == so sánh nội dung văn bản, không so sánh tham chiếu. Các toán tử logic là ! (not), && (and), || (or) và ^ (exclusive or, hoặc loại trừ).

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

Đầu ra:

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

&& và || ngắt mạch (short-circuit): toán hạng bên phải chỉ chạy khi nó có thể thay đổi kết quả. Chính điều đó làm cho user != null && user.IsActive an toàn. Các toán tử đơn & và | trên boolean luôn tính cả hai vế, điều hiếm khi bạn muốn trong một điều kiện.

Toán tử bit và toán tử dịch

Trên các kiểu số nguyên, &, |, ^ và ~ làm việc với từng bit, còn << và >> dịch chuyển các bit. Chúng được dùng cho cờ (flag), mặt nạ bit (mask), hàm băm và các giao thức cấp thấp:

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

Đầu ra:

3
True
False
101
1024
125
5
-1

Với một tập cờ có tên, enum gắn thuộc tính [Flags] rõ ràng hơn các hằng số nguyên, và HasFlag dễ đọc hơn một mặt nạ bit. C# 11 bổ sung >>>, phép dịch phải không dấu luôn điền số 0 kể cả với số âm.

Các toán tử null

Có ba toán tử dành cho các giá trị có thể là 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);
    }
}

Đầu ra:

Guest

0
5

a ?? b trả về a nếu nó khác null, ngược lại trả về b. a?.Member trả về null thay vì ném ngoại lệ khi a là null. C# 8 bổ sung a ??= b, chỉ gán b cho a khi a là null. Các toán tử này được trình bày chi tiết trong kiểu nullable.

Độ ưu tiên toán tử

Khi một biểu thức trộn nhiều toán tử, các hàng phía trên gắn chặt hơn. Các toán tử cùng một hàng nhóm từ trái sang phải, trừ phép gán, ?? và ?:, vốn nhóm từ phải sang trái. (Bản thân các toán hạng luôn được tính từ trái sang phải.)

Hai hệ quả nên biết: a + b * c nhân trước, còn x & mask == 0 so sánh trước (== gắn chặt hơn &), nên nó có nghĩa là x & (mask == 0) và không biên dịch được với số nguyên. Hãy viết (x & mask) == 0. Dấu ngoặc không tốn gì mà còn làm ý định rõ ràng.

Nạp chồng toán tử

Kiểu do bạn tự định nghĩa có thể quy định ý nghĩa của các toán tử. Đây là cách decimal, DateTime và TimeSpan hỗ trợ + và <:

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

Đầu ra:

33.49
True

Toán tử phải là public static, và một số toán tử đi theo cặp bắt buộc: định nghĩa < thì phải có >, và == thì phải có !=. Khi đã định nghĩa ==, trình biên dịch còn cảnh báo cho đến khi bạn ghi đè Equals và GetHashCode cho khớp. Chỉ nạp chồng toán tử khi ý nghĩa đã hiển nhiên, như với số, vector và tiền.