Operatorsöverlagring

Operatorer inom programmering (+, -, *, /, <, > med flera), har ett förutbestämt syfte och vi kan använda dem på våra värden. C# vet vad som ska göras när vi skriver 3 + 5. Men när vi skapar egna klasser så gömmer vi data i objekt och då kan vi inte förutsätta att det ska vara möjligt att till exempel addera eller subtrahera två objekt. Även om det ska vara möjligt kan vi inte förvänta oss att det ska fungera. Vidare har våra objekt ofta flera attribut med olika värden. Hur ska C# veta vilka av attributen som ska användas vid uträkningarna? Om det ska vara möjligt att addera två Car-objekt, ska då strängen _model eller heltalet _price eller båda användas i operationen?

Här kommer operatorsöverlagring in i bilden. När vi använder en operator är det en hemlig metod i C# som anropas och exekveras. I våra egenskapade klasser kan vi skriva över dessa metoder och på så sätt bestämma vad som ska ske när vi använder en sådan operator.

Addition, Car + Car

Låt säga att vi vill kunna addera två bil objekt och få reda på det sammanlagda priset. Först testar vi rakt av:

Addera två bilobjekt i huvudprogrammet

...
Car bmw = new Car("BMW", 100000);
Car volvo = new Car("Volvo", 80000);

Console.WriteLine("Addera priset: " + (bmw + volvo));
// Ger kompileringsfel: error CS0019: Operator '+' cannot be applied to operands of type 'Car' and 'Car'

Det gick inte så bra. +-operatorn (läses plus-operatorn) fungerar inte med två instanser av klassen Car, eftersom klassen Car inte innehåller metoden som definierar +-operatorn. Metoden som anropas vid + heter operator +. Vi lägger till en metod som heter operator +. Detta kallas att överlagra en operator eller operatorsöverlagring. Vi placerar den sist i klassen för att ha lite ordning och reda.

Lägg till en metod för att hantera addera bilobjekt i klassen Car

    ...
    // Operator overloading methods
    // Overloading the '+' operator for adding the price of two instances of the class Car
    public static int operator +(Car car1, Car car2)
    {
        return (int)(car1.GetPrice() + car2.GetPrice());
    }
}

Metoden operator + har två inparametrar, två instanser av klassen Car och returnerar summan av de två instansernas priser som ett heltal. Vi ser hur vi anropar metoden.

Testa metoden för att addera bilobjekt i huvudprogrammet

...
Console.WriteLine("Addera priset: " + (bmw + volvo));
// Ger utskriften: Addera priset: 180000

Nu tolkar C# volvo + bmw som att de både objektens pris ska adderas eftersom det finns en definition för operatorn +

Addition, Car + int

Vi kan vilja ha ut mer funktionalitet av operator +. Ska/Kan det till exempel vara möjligt att addera ett Car objekt med ett heltal?

Testa att addera en int och ett bilobjekt i huvudprogrammet

...
Console.WriteLine("Addera priset (Car+int): " + (bmw + 10000));
// Ger kompileringsfelet: error CS0019: Operator '+' cannot be applied to operands of type 'Car' and 'int'

Nu kraschar programmet för att metodenoperator + vill ha två inparametrar av typen Car. Vi kan lösa det genom att göra ännu en överlagring av metoden operator + där en inparameter är av typer Car och en inparameter av typen int.

Lägg till en metod för att addera en int och ett bilobjekt i klassen Car

    ...
    // Operator overloading methods
    ...

    // Overloading the '+' operator for adding the price of one instances of
    // the class Car and an integer amount
    public static int operator +(Car car1, int amount)
    {
        return (int)(car1.GetPrice() + amount);
    }
}

På nytt, testa att addera en int och ett bilobjekt i huvudprogrammet

...
Console.WriteLine("Addera priset (Car+int): " + (bmw + 10000));
// Ger utskriften: Addera priset (Car+int): 110000

Sammanfattning

Nu har vi överlagrat vår första operator. Det är ett programmerat beteende i C# att den, när man använder +, letar efter metoden operator + och exekverar den om den finns.

En regel vid operatoröverlagring är att minst en av operanderna ska vara av den fördefinierade typen. I vår första metod är båda operanderna av klassen Car och i vår andra metod är första operanden av klassen Car och den andra en int.

Det finns alltså en specifik metod för varje aritmetisk operator +, -, *, /, %. Detta gäller även jämförelseoperatorerna som ==, <, > <= >= m.m. Genom att överlagra vissa eller alla dessa metoder kan vi programmera vilka operationer som ska vara möjliga för objekt av en viss klass. Till exempel hur två objekt av klassen Car ska kunna jämföras och vad som styr vilket objekt som är minst, störst etc. Vid == (ekvivalens) heter till exempel metoden operator ==.

Alla operatorer går inte att överlagra, mer om det i C#s dokumentation.