Operator Overloading In C#

The binary operators such as = =, ! =, <, >, < =, > = can be overloaded only as pairs. Remember that when a binary arithmetic operator is overloaded, corresponding assignment operators also get overloaded automatically. For example if we overload + operator, it implicitly overloads the + = operator also.

Operator Overloading & Inheritance

Even though the overloaded operators are declared as static, they are inherited to the derived classes. Because operator declaration always requires the class or struct in which the operator is declared, to participate in the signature of the operator, it is jot possible for an operator declared in a derived class to hide an operator declared in a base class. Thus the new modifier is never required and there never permitted in an operator declaration.

// Binary operator overloading  
// Author: [email protected]  
using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public static Complex operator +(Complex c1, Complex c2)  
    {  
        Complex temp = new Complex();  
        temp.x = c1.x + c2.x;  
        temp.y = c1.y + c2.y;  
        return temp;  
    }  
}  
class MyComplex : Complex  
{  
    private double x;  
    private double y;  
    public MyComplex(double i, double j)  
    {  
        x = i;  
        y = j;  
    }  
    public MyComplex()  
    {  
    }  
    public new void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        MyComplex mc1 = new MyComplex(1.5, 2.5);  
        mc1.ShowXY();  
        MyComplex mc2 = new MyComplex(3.5, 4.5);  
        mc2.ShowXY();  
        MyComplex mc3 = new MyComplex();  
        //mc3 = mc1 + mc2;  
        //mc3.ShowXY();  
    }  
}

Overloading Equality Operators

Since all user defined classes, by default, inherit from Syste.object, they inherit the System.object.Equals() method. The default implementation of Equals() method provide a reference based comparison. But it is possible to override this method inside the user-defined class so that they can provide a value-based comparison. The following class is an example for a reference-based comparison of Equals() method.

// Equals() Default Implementation  
// Author: [email protected]  
using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(10, 20);  
        c2.ShowXY(); // displays 10 & 20  
        Complex c3 = c2;  
        c3.ShowXY(); // dislplays 10 & 20  
        if (c1.Equals(c2))  
            Console.WriteLine("OK");  
        else  
            Console.WriteLine("NOT OK");  
        if (c2.Equals(c3))  
            Console.WriteLine("OK1");  
    }  
}

The above program on execution displays "NOT OK" and "OK1". That means the Equals() method by default do a reference comparison. Remember that the values of objects c1 and c2 are same. But they have different references. But in the case of c2 and c3, they refer to the same object on the memory.

But in C#, it is possible to override the Equals() method inside any user defined class as shown below, so that they can do a value-based comparison.

// Equals() Overriding Default Implementation  
// Author: [email protected]  
using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public override bool Equals(object o)  
    {  
        if ((Complex)o.x == this.x && (Complex)o.y == this.y)  
            return true;  
        else  
            return false;  
    }  
    public override int GetHashCode()  
    {  
        return this.ToString().GetHashCode();  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(10, 20);  
        c2.ShowXY(); // displays 10 & 20  
        Complex c3 = c2;  
        c3.ShowXY(); // dislplays 10 & 20  
        if (c1.Equals(c2))  
            Console.WriteLine("OK");  
        else  
            Console.WriteLine("NOT OK");  
        if (c2.Equals(c3))  
            Console.WriteLine("OK1");  
    }  
}

Now the program displays both "OK" and "OK1" on the command prompt.

Remember that when we override the Equals() method inside a class, we will need to override GetHashCode() method also.

Now let us see how we can override the operator = = and ! = so that they can do the comparisons.

// Overloading = = and ! = operators  
// Author: [email protected]  
using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public override bool Equals(object o)  
    {  
        if ((Complex)o.x == this.x && (Complex)o.y == this.y)  
            return true;  
        else  
            return false;  
    }  
    public override int GetHashCode()  
    {  
        return this.ToString().GetHashCode();  
    }  
    public static bool operator = = (Complex c1, Complex c2)  
    {  
return c1.Equals(c2);  
}  
public static bool operator ! = (Complex c1, Complex c2)  
{  
return ! c1.Equals(c2);  
}  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(10, 20);  
        c2.ShowXY(); // displays 10 & 20  
        Complex c3 = c2;  
        c3.ShowXY(); // dislplays 10 & 20  
        if (c1 = = c2)  
            Console.WriteLine("OK");  
        else  
            Console.WriteLine("NOT OK");  
        if (c2 ! = c3)  
Console.WriteLine("OK1");  
    }  
}

Instead of repeating the codes I just call the override Equals() method inside the operator functions. Remember that if we overload the = = operator inside a class or struct we must also override ! = operator.

Summary

1. The user defined operator declarations can't modify the syntax, precedence or associatively of an operator. For example, a + operator is always a binary operator having a predefined precedence and an associatively of left to right.
2. User defined operator implementations are given preference over predefined implementations.
3. Operator overload methods can't return void.
4. The operator overload methods can be overloaded just like any other methods in C#. The overloaded methods should differ in their type of arguments and/or number of arguments and/or order of arguments. Remember that in this case also the return type is not considered as part of the method signature.
5. Remember that the capability to overload operators is not a requirement of the common language specification. Hence, not all .NET aware languages supports operator overloading.