Přetížení operátoru (Referenční dokumentace jazyka C#)

Uživatelem definovaný typ může přetížit předdefinovaný operátor jazyka C#. To znamená, že typ může poskytnout vlastní implementaci operace v případě, že jeden nebo oba operandy jsou tohoto typu. Oddíl Přetížené operátory ukazuje, které operátory jazyka C# mohou být přetíženy.

K operator deklaraci operátoru použijte klíčové slovo . Deklarace operátoru musí splňovat následující pravidla:

  • Obsahuje public modifikátor i static .
  • Unární operátor má jeden vstupní parametr. Binární operátor má dva vstupní parametry. V každém případě musí mít alespoň jeden parametr typ nebo T T? kde je T typ, který obsahuje deklaraci operátoru.

Následující příklad definuje zjednodušenou strukturu, která reprezentuje racionální číslo. Struktura přetěžuje některé aritmetické operátory:

using System;

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

Předchozí příklad můžete rozšířit definováním implicitního převodu z int na Fraction . Přetížené operátory by pak podporovaly argumenty těchto dvou typů. To znamená, že by bylo možné přidat celé číslo na zlomek a jako výsledek získat zlomek.

Klíčové slovo použijete operator také k definování vlastního převodu typu. Další informace najdete v tématu Operátory převodu definované uživatelem.

Přetížené operátory

Následující tabulka obsahuje informace o přetížení operátorů jazyka C#:

Operátory Přetížení
+x, -x, !x, ~x, ++ , , -- true, false Tyto unární operátory mohou být přetížené.
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 Tyto binární operátory mohou být přetíženy. Některé operátory musí být v párech přetížené. Další informace najdete v poznámce za touto tabulkou.
x && y, x || y Podmíněné logické operátory nelze přetížit. Pokud však typ s přetíženými operátory a přetíží operátor or určitým způsobem, lze operátor nebo v uvedeném pořadí vyhodnotit pro true false & | && || operandy tohoto typu. Další informace najdete v části Podmíněné logické operátory definované uživatelem specifikace jazyka C#.
a[i], a?[i] Přístup k elementu není považován za přetížený operátor, ale můžete definovat indexer.
(T)x Operátor přetypování nelze přetížit, ale můžete definovat vlastní převody typů, které lze provést výrazem přetypování. Další informace najdete v tématu Operátory převodu definované uživatelem.
+=, -= , , , ,|*= /= %= &= =, ^= , <<=, >>= Složené operátory přiřazení nelze explicitně přetížit. Při přetížení binárního operátoru je však implicitně přetížen také odpovídající složený operátor přiřazení, pokud existuje. Například se += vyhodnocuje pomocí + metody , která může být přetížena.
^x, x = y, x.y, x?.y , c ? t : f, x ?? y, x ?? = y, x.. y, x->y => , f(x), as, await, checked , unchecked, default, delegate, is, nameof, new, sizeof, stackalloc, switch, typeof, with Tyto operátory nelze přetížit.

Poznámka

Operátory porovnání musí být v párech přetížené. To znamená, že pokud je některý z operátorů dvojice přetížen, musí být přetížen také druhý operátor. Tyto páry jsou následující:

  • == Operátory != a
  • < Operátory > a
  • <= Operátory >= a

specifikace jazyka C#

Další informace najdete v následujících částech specifikace jazyka C#:

Viz také