Overloads – operátor (Referenční dokumentace jazyka C#)

  • Článek
  • 2 min ke čtení

Uživatelsky 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.

Použijte operator klíčové slovo k deklarování operátoru. Deklarace operátoru musí splňovat následující pravidla:

  • Zahrnuje jak a, tak i public static modifikátor.
  • 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 T T? , nebo kde T je typ, který obsahuje deklaraci operátoru.

Následující příklad definuje zjednodušenou strukturu, která představuje 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 zvětšit definováním implicitního převodu z int na Fraction . Přetížené operátory pak podporují argumenty těchto dvou typů. To znamená, že by bylo možné přidat celé číslo do zlomku a získat zlomek jako výsledek.

Klíčové slovo můžete také použít operator k definování vlastního převodu typu. Další informace naleznete v tématu uživatelsky definované operátory převodu.

Přetížené operátory

Následující tabulka poskytuje 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íženy.
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áru přetížené. Další informace najdete v poznámce, které následují po této tabulce.
x && y, x || y Podmíněné logické operátory nelze přečítat. Nicméně pokud typ s přetíženou true a false operátory také přetěžuje & | operátor OR určitým způsobem, && || lze pro operandy daného typu vyhodnotit operátor OR (v uvedeném pořadí). Další informace naleznete v části Podmíněné logické operátory definované uživatelem v tématu specifikace jazyka C#.
][, a?[i] Přístup k prvku není považován za přetížený operátor, ale můžete definovat indexer.
(T) x Operátor přetypování nemůže být přetížen, ale můžete definovat vlastní převody typů, které mohou být provedeny výrazem přetypování. Další informace naleznete v tématu uživatelsky definované operátory převodu.
+=, -= , *= , /= , %= , &= , |=, ^= , <<=, >>= Operátory složeného přiřazení nelze explicitně přečítat. Nicméně při přetížení binárního operátoru je odpovídající složený operátor přiřazení, pokud existuje, také implicitně přetížený. Například += je vyhodnocen pomocí + , který může být přetížen.
^ x, x = y, x. y, x?.y , c? t: f, x?? y, x?? = y, x... y, x->y, => , f (x), as, await, zaškrtnutí, nezaškrtnuto, Default, Delegate, je, nameof, New, sizeof, stackalloc, Switch, typeof s Tyto operátory nemůžou být přetížené.

Poznámka

Operátory porovnání musí být přetíženy v páru. To znamená, že pokud je jeden operátor páru přetížený, druhý operátor musí být přetížený. Tyto páry jsou následující:

  • ==``!=operátory a
  • <``>operátory a
  • <=``>=operátory a

specifikace jazyka C#

Další informace naleznete v následujících oddílech specifikace jazyka C#:

Viz také