Megosztás a következőn keresztül:

Operátorok túlterhelése – előre definiált, nem meghatározott, számtani, egyenlőségi és összehasonlító operátorok

  • Cikk

A felhasználó által definiált típus túlterhelhet egy előre definiált C# operátort. Ez azt jelzi, hogy egy típus lehetővé teheti egy művelet egyéni implementálását abban az esetben, ha az egyik vagy mindkét operandus ilyen típusú. A Túlterhelhető operátorok szakasz azt mutatja be, hogy mely C#-operátorok terhelhetők túl.

operator A kulcsszó használatával deklarálhat egy operátort. Az operátor-deklarációnak meg kell felelnie a következő szabályoknak:

  • Tartalmaz egy public és egy static módosító is.
  • A nem kötelező operátorok egyetlen bemeneti paraméterrel rendelkeznek. A bináris operátor két bemeneti paraméterrel rendelkezik. Minden esetben legalább egy paraméternek típussal TT?T vagy az operátor deklarációt tartalmazó típussal kell rendelkeznie.

Az alábbi példa egy egyszerűsített struktúrát határoz meg, amely egy racionális számot jelöl. A struktúra túlterheli az aritmetikai operátorok némelyikét:

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

Az előző példát kiterjesztheti úgy, hogy implicit konverziót határoz meg a célról int a következőre Fraction: . Ezután a túlterhelt operátorok támogatnák a két típus argumentumait. Ez azt jelenti, hogy egész számokat adhat hozzá egy törthez, és ennek eredményeként beolvashat egy törtet.

A kulcsszóval operator egyéni típuskonvertálást is definiálhat. További információ: Felhasználó által definiált konverziós operátorok.

Túlterhelhető operátorok

Az alábbi táblázat a túlterhelhető operátorokat mutatja be:

Operátorok Jegyzetek
+x, -x, !x, ~x++, --, truefalse Az true operátorokat együtt false kell túlterhelni.
x + y, x - y, x * y, x / yx % y
x & y, x | y, x ^ y
x << y, , x >> yx >>> y
x == y, x != y, x < y, x > yx <= yx >= y A következő párokban kell túlterhelni: == és !=, < és >, <= és >=.

Nem túlterhelhető operátorok

Az alábbi táblázat azokat az operátorokat mutatja be, amelyek nem terhelhetők túl:

Operátorok Alternatívák
x && y, x || y Túlterhelje mind az true operátorokat false , mind az & operátorokat | . További információ: Felhasználó által definiált feltételes logikai operátorok.
a[i], a?[i] Indexelő definiálása.
(T)x Egyéni típuskonvertálások definiálása, amelyeket egy öntött kifejezés hajthat végre. További információ: Felhasználó által definiált konverziós operátorok.
+=, -=, *=, /=, %=&=, |=, ^=, <<=, , >>=>>>= Túlterhelje a megfelelő bináris operátort. Ha például túlterheli a bináris + operátort, += implicit módon túlterhelődik.
^x, x = y, x.y, x?.yc ? t : f, x ?? y, ??= y
x..y, x->y, =>, f(x), asawait, checked, unchecked, default, delegate, is, nameof, , new,
sizeof, stackalloc, switch, typeofwith		 Nincs.

C# nyelvspecifikáció

További információt a C# nyelvspecifikációjának alábbi szakaszaiban talál:

Lásd még