Операторы в 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. Это причина очень частой ошибки: int percent = done / total * 100; равно 0 всякий раз, когда done < total, потому что done / total уже равно 0. Сначала умножайте (done * 100 / total) или делите как double.

Деление целого числа или decimal на ноль выбрасывает DivideByZeroException. Деление double на ноль исключения не выбрасывает; получается бесконечность или NaN для 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");
        }
    }
}

Вывод:

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 показывает особенность: 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

Для работы со значениями, которые могут быть 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, иначе b. a?.Member возвращает null вместо исключения, когда a равно null. C# 8 добавил a ??= b, который присваивает b переменной a только тогда, когда a равно null. Подробно они разобраны в разделе типы, допускающие null.

Приоритет операторов

Когда в выражении смешаны операторы, строки выше связывают сильнее. Операторы одной строки группируются слева направо, кроме присваивания, ?? и ?:, которые группируются справа налево. (Сами операнды всегда вычисляются слева направо.)

Два следствия, которые стоит знать: 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 согласованно. Перегружайте операторы только там, где их смысл очевиден, например для чисел, векторов и денег.