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。这会导致一个非常常见的 bug：只要 done < total，int percent = done / total * 100; 的结果就是 0，因为 done / total 已经是 0 了。先做乘法（done * 100 / total），或者按 double 做除法。

整数或 decimal 除以零会抛出 DivideByZeroException。double 除以零不会抛出异常；它得到无穷大，而 0.0 / 0.0 得到 NaN：

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 以及数学上的“取模”不同，后两者在除数为正时结果总是非负的：

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 或减 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

对于有名字的一组标志，带 [Flags] 特性的枚举比整数常量更清晰，HasFlag 也比掩码更好读。C# 11 新增了 >>>，即无符号右移，即使对负数也会用零填充。

空值运算符

有三个运算符专门用于处理可能为 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 时返回 a，否则返回 b。a?.Member 在 a 为 null 时返回 null，而不是抛出异常。C# 8 新增了 a ??= b，它只在 a 为 null 时才把 b 赋给 a。可空类型页面对这些运算符有深入介绍。

运算符优先级

当一个表达式混用多个运算符时，表中越靠上的结合得越紧。同一行的运算符从左到右结合，但赋值、?? 和 ?: 例外，它们从右到左结合。（操作数本身总是从左到右求值。）

有两个后果值得了解：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。只在含义一目了然的地方重载运算符，比如数字、向量和金额。