C#の演算子：算術、剰余、論理、ビット演算、優先順位

演算子は1つ、2つ、または3つのオペランドを受け取り、値を生成します：a + b、!done、x ?? fallback。C#の演算子はC、Java、JavaScriptのものに近いですが、いくつかは初めての人を驚かせる動作をします。特に整数の除算と % の符号です。

算術演算子

+、-、*、/、% はすべての数値型に使えます。結果の型はオペランドに従います。2つの 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; は、done / total の時点ですでに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や数学の「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 の例は1つの癖を示しています。byte + int は int になるので level = level + 10; はコンパイルできませんが、複合代入には変数の型に戻す暗黙のキャストが含まれるので 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 は安全です。ブール値に対する1文字の & と | は常に両辺を評価し、条件でそれが望ましいことはまれです。

ビット演算子とシフト演算子

整数型では、&、|、^、~ は個々のビットに作用し、<< と >> はビットをシフトします。フラグ、マスク、ハッシュ、低レベルのプロトコルに使われます。

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] 属性を付けたenumのほうが明確で、マスクより HasFlag のほうが読みやすくなります。C# 11では、負の数でもゼロで埋める符号なしの右シフト >>> が追加されました。

null演算子

null になりうる値を扱うための演算子が3つあります。

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 を、nullなら b を返します。a?.Member は、a がnullのとき例外を投げずにnullを返します。C# 8では、a がnullのときだけ b を a に代入する a ??= b が追加されました。これらについてはnull許容型で詳しく扱います。

演算子の優先順位

式に複数の演算子が混ざっている場合、上の行ほど強く結び付きます。同じ行の演算子は左から右にまとまりますが、代入、??、?: は右から左にまとまります。（オペランド自体は常に左から右に評価されます。）

知っておくべき結果が2つあります。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 をオーバーライドするまで、コンパイラが警告も出します。演算子のオーバーロードは、数値、ベクトル、お金のように意味が明らかな場合に限って使います。