Operadores em C#: aritméticos, módulo, lógicos, bit a bit e precedência

Um operador recebe um, dois ou três operandos e produz um valor: a + b, !done, x ?? fallback. Os operadores de C# são próximos dos de C, Java e JavaScript, mas alguns se comportam de formas que surpreendem quem está começando, principalmente a divisão inteira e o sinal do %.

Operadores aritméticos

+, -, *, / e % funcionam em todo tipo numérico. O tipo do resultado segue os operandos: dois valores int produzem um int, um int e um double produzem um 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
    }
}

Saída:

22
12
85
3
2
3.4
3.4
3
3.4

A divisão inteira trunca em direção a zero. 17 / 5 é 3 e -17 / 5 é -3. Isso causa um bug muito comum: int percent = done / total * 100; é 0 sempre que done < total, porque done / total já é 0. Multiplique primeiro (done * 100 / total) ou divida como double.

Dividir um inteiro ou um decimal por zero lança DivideByZeroException. Dividir um double por zero não lança nada; produz infinito, ou NaN para 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");
        }
    }
}

Saída:

True
True
False
DivideByZeroException

O operador de resto e os números negativos

% retorna o resto da divisão, e o resultado tem o sinal do operando da esquerda. Isso difere do Python e do "mod" matemático, que são sempre não negativos para um divisor positivo:

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

Saída:

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

Use o auxiliar Mod sempre que o lado esquerdo puder ser negativo e o resultado for um índice: days[(today + offset) % 7] lançaria uma IndexOutOfRangeException para uma soma negativa. Testar números ímpares tem a mesma armadilha: n % 2 == 1 é false para ímpares negativos; teste n % 2 != 0.

Atribuição, atribuição composta e incremento

= atribui. As formas compostas +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= combinam uma operação com a atribuição. ++ e -- somam ou subtraem 1 e existem nas formas prefixa e pós-fixa, que diferem no valor que retornam:

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

Saída:

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

O caso do byte mostra uma peculiaridade: level = level + 10; não compila, porque byte + int é um int, mas level += 10; compila, porque a atribuição composta inclui um cast implícito de volta para o tipo da variável. Esse cast dá a volta no overflow (250 + 10 vira 4).

Operadores de comparação e lógicos

Os operadores de comparação (==, !=, <, >, <=, >=) retornam um bool. Para strings, == compara o texto, não as referências. Os operadores lógicos são ! (não), && (e), || (ou) e ^ (ou exclusivo).

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

Saída:

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

&& e || fazem curto-circuito: o operando da direita só executa quando pode mudar o resultado. É isso que torna user != null && user.IsActive seguro. Os operadores simples & e | em booleanos sempre avaliam os dois lados, o que raramente é o que você quer em uma condição.

Operadores bit a bit e de deslocamento

Em tipos inteiros, &, |, ^ e ~ trabalham em bits individuais, e << e >> os deslocam. Eles são usados em flags, máscaras, hashing e protocolos de baixo nível:

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

Saída:

3
True
False
101
1024
125
5
-1

Para conjuntos de flags com nome, um enum com o atributo [Flags] é mais claro que constantes inteiras, e HasFlag se lê melhor que uma máscara. O C# 11 adicionou >>>, um deslocamento à direita sem sinal que preenche com zeros mesmo para números negativos.

Operadores de null

Três operadores existem para trabalhar com valores que podem ser 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);
    }
}

Saída:

Guest

0
5

a ?? b retorna a, a menos que seja null, e então b. a?.Member retorna null em vez de lançar exceção quando a é null. O C# 8 adicionou a ??= b, que atribui b a a só quando a é null. Eles são cobertos em detalhe em tipos anuláveis.

Precedência dos operadores

Quando uma expressão mistura operadores, as linhas de cima se ligam com mais força. Operadores na mesma linha se agrupam da esquerda para a direita, exceto a atribuição, ?? e ?:, que se agrupam da direita para a esquerda. (Os operandos em si sempre são avaliados da esquerda para a direita.)

Duas consequências que vale conhecer: a + b * c multiplica primeiro, e x & mask == 0 compara primeiro (== se liga com mais força que &), então significa x & (mask == 0) e não compila para inteiros. Escreva (x & mask) == 0. Parênteses não custam nada e deixam a intenção óbvia.

Sobrecarga de operadores

Seus próprios tipos podem definir o que os operadores significam. É assim que decimal, DateTime e TimeSpan aceitam + e <:

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

Saída:

33.49
True

Os operadores precisam ser public static, e alguns vêm em pares obrigatórios: definir < exige >, e == exige !=. Com == definido, o compilador também avisa até você sobrescrever Equals e GetHashCode para combinar. Sobrecarregue operadores só onde o significado é óbvio, como em números, vetores e dinheiro.