Operátortúlterhelés ebben a kurzusban:

A(z) Operátortúlterhelés fogalomról

A legfontosabb aritmetikai és összehasonlító operátorok saját osztályokhoz és struktúrákhoz is hozzáigazíthatók. Ezt operátortúlterhelésnek nevezzük.

Ez a cikk részletesen tárgyalja a szintaxist, valamint azt is, hogy mely operátorok terhelhetők túl, és melyek nem.

A legtöbb operátor alakja a következő:

static <return type> operaator <operator symbols>(<parameters>);

A típuskonverziós operátorok alakja a következő:

static (explicit|implicit) operator <cast-to-type>(<cast-from-type> <parameter name>);

Az operátorok ugyanúgy viselkednek, mint a statikus metódusok.

• Az operátorszimbólum a metódusazonosító helyét veszi át, emellett paraméterekkel és visszatérési típussal rendelkezik. A paraméterekre és a visszatérési típusra vonatkozó típusszabályok megfelelnek a megérzésednek, és számíthatsz rá, hogy a fordító részletes útmutatást ad.
• Bináris műveleteknél az első paraméter kapja a művelet bal oldali argumentumát.
• Az operátorok szignatúrája bináris műveleteknél két paraméterből és egy visszatérési típusból áll, egyoperandusú operátoroknál pedig egyetlen paraméterből és egy visszatérési típusból.
• Bináris operátoroknál az egyik paraméter típusának a deklaráló osztály típusával kell megegyeznie.
• Típuskonverzióknál vagy a paraméternek, vagy a visszatérési típusnak meg kell egyeznie a deklaráló osztály típusával.
• Növelő és csökkentő operátoroknál a paraméter és a visszatérési típus is a deklaráló osztály típusa kell legyen.

Szintaxispéldák:

struct Point
{
    decimal x;
    decimal y;

    public static bool operator ==(Point pt, Point ptOther)
    {
        return pt.x == ptOther.x && pt.y == ptOther.y;
    }

    public static bool operator !=(Point pt, Point ptOther)
    {
        return !(pt == ptOther);
    }

    public static Point operator *(Point pt, decimal scale)
    {
        var ptNew = new Point();
        ptNew.x = pt.x * scale;
        ptNew.y = pt.y * scale;
        return ptNew;
    }

    public static implicit operator Point((decimal x, decimal y) xy)
    {
        var pt = new Point();
        pt.x = xy.x;
        pt.y = xy.y;
        return pt;
    }

    public static explicit operator (decimal x, decimal y)(Point pt)
    {
        return (pt.x, pt.y);
    }
}

Gyakran célravezető megvalósítani egy Equals() metódust, és meghívni azt a == operátorból. Hasonlóképpen, összehasonlításokhoz implementálhatod az IComparable interfészt. Mindkét esetben két legyet üthetsz egy csapásra, sőt, még egy kicsivel többre is.

Ne feledd, hogy nem hozhatsz létre operátorokat olyan szimbólumokból, amelyek nem részei az operátorok szabványos készletének. Csak meglévő szimbólumokat használhatsz azokhoz a műveletekhez, amelyeknél a dokumentáció kimondja, hogy túlterhelhetők. A túlterhelhető operátorok itt vannak felsorolva.

Figyeld meg, hogy a paraméterek sorrendje számít, ha a típusuk eltér. A fenti példakódban a pt * 10m érvényes kifejezés, a 10m * pt viszont nem fordul le.

Hivatkozások

Az operátortúlterhelésről szóló dokumentáció részletesen ismerteti a szintaxist.