Operadores en C#: aritméticos, módulo, lógicos, bit a bit y precedencia

Un operador recibe uno, dos o tres operandos y produce un valor: a + b, !done, x ?? fallback. Los operadores de C# se parecen mucho a los de C, Java y JavaScript, pero algunos se comportan de formas que sorprenden a los recién llegados, sobre todo la división entera y el signo de %.

Operadores aritméticos

+, -, *, / y % funcionan con todos los tipos numéricos. El tipo del resultado sigue a los operandos: dos valores int producen un int, un int y un double producen un 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
    }
}

Salida:

22
12
85
3
2
3.4
3.4
3
3.4

La división entera trunca hacia cero. 17 / 5 es 3 y -17 / 5 es -3. Provoca un bug muy común: int percent = done / total * 100; da 0 siempre que done < total, porque done / total ya es 0. Multiplica primero (done * 100 / total) o divide como double.

Dividir un entero o un decimal entre cero lanza DivideByZeroException. Dividir un double entre cero no lanza nada; produce infinito, o NaN con 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");
        }
    }
}

Salida:

True
True
False
DivideByZeroException

El operador módulo y los números negativos

% devuelve el resto de la división, y su resultado toma el signo del operando izquierdo. Esto es distinto de Python y del "mod" matemático, que nunca son negativos con un 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
    }
}

Salida:

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

Usa el método auxiliar Mod siempre que el lado izquierdo pueda ser negativo y el resultado sea un índice: days[(today + offset) % 7] lanzaría una IndexOutOfRangeException con una suma negativa. Comprobar si un número es impar tiene la misma trampa: n % 2 == 1 es false para los impares negativos; comprueba n % 2 != 0.

Asignación, asignación compuesta e incremento

= asigna. Las formas compuestas +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>= combinan una operación con la asignación. ++ y -- suman o restan 1, y tienen formas prefija y postfija que se diferencian en el valor que devuelven:

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

Salida:

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

El caso de byte muestra una peculiaridad: level = level + 10; no compila, porque byte + int es un int, pero level += 10; sí, porque la asignación compuesta incluye un cast implícito de vuelta al tipo de la variable. Ese cast da la vuelta si hay desbordamiento (250 + 10 se convierte en 4).

Operadores de comparación y lógicos

Los operadores de comparación (==, !=, <, >, <=, >=) devuelven un bool. En los strings, == compara el texto, no las referencias. Los operadores lógicos son ! (no), && (y), || (o) y ^ (o 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
    }
}

Salida:

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

&& y || hacen cortocircuito: el operando derecho solo se ejecuta cuando puede cambiar el resultado. Eso es lo que hace segura la expresión user != null && user.IsActive. Los operadores simples & y | con booleanos evalúan siempre los dos lados, lo que rara vez es lo que quieres en una condición.

Operadores bit a bit y de desplazamiento

En los tipos enteros, &, |, ^ y ~ trabajan sobre bits individuales, y << y >> los desplazan. Se usan para indicadores, máscaras, hashing y protocolos de bajo nivel:

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

Salida:

3
True
False
101
1024
125
5
-1

Para conjuntos de indicadores con nombre, un enum con el atributo [Flags] es más claro que unas constantes enteras, y HasFlag se lee mejor que una máscara. C# 11 añadió >>>, un desplazamiento a la derecha sin signo que rellena con ceros incluso en los números negativos.

Operadores de null

Existen tres operadores para trabajar con valores que pueden 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);
    }
}

Salida:

Guest

0
5

a ?? b devuelve a salvo que sea null, y entonces b. a?.Member devuelve null en lugar de lanzar una excepción cuando a es null. C# 8 añadió a ??= b, que asigna b a a solo cuando a es null. Se explican en detalle en tipos nullable.

Precedencia de operadores

Cuando una expresión mezcla operadores, las filas más altas se aplican antes. Los operadores de una misma fila se agrupan de izquierda a derecha, salvo la asignación, ?? y ?:, que se agrupan de derecha a izquierda. (Los operandos en sí se evalúan siempre de izquierda a derecha.)

Dos consecuencias que conviene conocer: a + b * c multiplica primero, y x & mask == 0 compara primero (== tiene más precedencia que &), así que significa x & (mask == 0) y no compila con enteros. Escribe (x & mask) == 0. Los paréntesis no cuestan nada y dejan clara la intención.

Sobrecarga de operadores

Tus propios tipos pueden definir qué significan los operadores. Así es como decimal, DateTime y TimeSpan admiten + y <:

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

Salida:

33.49
True

Los operadores deben ser public static, y algunos van en parejas obligatorias: definir < exige >, y == exige !=. Con == definido, el compilador también avisa hasta que sobrescribas Equals y GetHashCode para que coincidan. Sobrecarga operadores solo donde el significado sea evidente, como con números, vectores y dinero.