Sobrecarga do operador - operadores unários, aritméticos, de igualdade e de comparação predefinidos

  • Artigo

Um tipo definido pelo usuário pode sobrecarregar um operador C# predefinido. Ou seja, um tipo pode fornecer a implementação personalizada de uma operação no caso de um ou ambos os operandos serem desse tipo. A seção Operadores sobrecarregáveis mostra quais operadores C# podem ser sobrecarregados.

Use a operator palavra-chave para declarar um operador. A declaração do operador deve satisfazer as seguintes regras:

  • Inclui um public e um static modificador.
  • Um operador unário tem um parâmetro de entrada. Um operador binário tem dois parâmetros de entrada. Em cada caso, pelo menos um parâmetro deve ter tipo T ou T? onde T é o tipo que contém a declaração do operador.

O exemplo a seguir define uma estrutura simplificada para representar um número racional. A estrutura sobrecarrega alguns dos operadores aritméticos:

public readonly struct Fraction
{
    private readonly int num;
    private readonly int den;

    public Fraction(int numerator, int denominator)
    {
        if (denominator == 0)
        {
            throw new ArgumentException("Denominator cannot be zero.", nameof(denominator));
        }
        num = numerator;
        den = denominator;
    }

    public static Fraction operator +(Fraction a) => a;
    public static Fraction operator -(Fraction a) => new Fraction(-a.num, a.den);

    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.num * b.den + b.num * a.den, a.den * b.den);

    public static Fraction operator -(Fraction a, Fraction b)
        => a + (-b);

    public static Fraction operator *(Fraction a, Fraction b)
        => new Fraction(a.num * b.num, a.den * b.den);

    public static Fraction operator /(Fraction a, Fraction b)
    {
        if (b.num == 0)
        {
            throw new DivideByZeroException();
        }
        return new Fraction(a.num * b.den, a.den * b.num);
    }

    public override string ToString() => $"{num} / {den}";
}

public static class OperatorOverloading
{
    public static void Main()
    {
        var a = new Fraction(5, 4);
        var b = new Fraction(1, 2);
        Console.WriteLine(-a);   // output: -5 / 4
        Console.WriteLine(a + b);  // output: 14 / 8
        Console.WriteLine(a - b);  // output: 6 / 8
        Console.WriteLine(a * b);  // output: 5 / 8
        Console.WriteLine(a / b);  // output: 10 / 4
    }
}

Você pode estender o exemplo anterior definindo uma conversão implícita de int para Fraction. Então, operadores sobrecarregados apoiariam argumentos desses dois tipos. Ou seja, tornar-se-ia possível adicionar um inteiro a uma fração e obter uma fração como resultado.

Você também usa a operator palavra-chave para definir uma conversão de tipo personalizada. Para obter mais informações, consulte Operadores de conversão definidos pelo usuário.

Operadores sobrecarregados

A tabela a seguir mostra os operadores que podem ser sobrecarregados:

Operadores Notas
+x, -x, , !x, ++~x, --, true,false Os operadores e false os true operadores devem ser sobrecarregados em conjunto.
x + y, x - y, x * y, x / y, x % y,
x & y, x | y, x ^ y,
x << y, x >> y, x >>> y
x == y, x != y, x < y, x > y, x <= y, x >= y Deve ser sobrecarregado em pares da seguinte forma: == e !=, < e >, <= e >=.

Operadores não sobrecarregáveis

A tabela a seguir mostra os operadores que não podem ser sobrecarregados:

Operadores Alternativas
x && y, x || y Sobrecarregar os true operadores e false e os & operadores ou | . Para obter mais informações, consulte Operadores lógicos condicionais definidos pelo usuário.
a[i], a?[i] Defina um indexador.
(T)x Defina conversões de tipo personalizadas que podem ser executadas por uma expressão de transmissão. Para obter mais informações, consulte Operadores de conversão definidos pelo usuário.
+=, -=, , /=*=, %=, &=, |=, ^=<<=>>=>>>= Sobrecarregue o operador binário correspondente. Por exemplo, quando você sobrecarrega o operador binário + , += está implicitamente sobrecarregado.
^x, x = y, , x.y, c ? t : fx?.y, x ?? y, ??= y,
x..y, x->y, , =>, , awaitdefaultasuncheckednewcheckeddelegateisnameoff(x)
sizeof, stackalloc, switch, typeof, with		 Nenhum.

Especificação da linguagem C#

Para obter mais informações, consulte as seguintes seções da especificação da linguagem C#:

Consulte também