Home	»	C#	»	Operator Overloading

All unary and binary operators have pre-defined semantic implementations, that are automatically available in any expressions. In addition to this pre-defined implementations, user defined implementations can also be introduced in C#. The mechanism of giving a special meaning to a standard C# operator with respect to a user defined data type such as classes or structures is known as Operator Overloading.

Overloadable Operators

Operators can be overloaded to give them new additional semantic meaning. However, some of the C# operators cannot be overloaded at all. The following table shows the operators and their overloadability in C#.

Operators	Overloadability
+,-,*,/,%,`&`,\|,<<,>>	All C# binary operators can be overloaded.
+,-,!,~,++,--,true,false	All C# unary operators can be overloaded.
==,!=,<,>,<==,>==	All relational operators can be overloaded, but only as pairs.
`&&`,\|\|	Can't be overloaded
(), (Conversion operator)	Can't be overloaded
+=,-=,*=,/=,%=	These compound assignment operators can be overloaded. But in C#, these operators are automatically overloaded when the respective binary operator is overloaded
=,.,?,->, new, is , as, sizeof	Can't be overloaded

Need for Operator Overloading

Object oriented programming must exhibit polymorphism. Operator overloading is one such mechanism through which C# achieves polymorphism, though other mechanisms for polymorphism also exist.

Consider, for example , that the + operator is defined normally to add two numeric values irrespective of their type. In this sense + operator is overloaded by definition.
Thus,

int a = 20 + 30;
is a valid operation.

Moreover, if a programmer wishes to use the same operator + to mean adding (concatenation) two strings, the + operation must be overloaded accordingly. But for operator overloading feature it would not be possible to ascertain polymorphism in C#. By overloading + appropriatly, we can use + operator in the following manner.

String = "ABC" + "XYZ";

Defining Operator Overloading

In C#, a special function called operator function is used for overloading purpose. These special fucntion or method must be public and static. They can take only value arguments. The ref and out parameters are not allowed as arguments to operator functions. The general form of an operator function is as follows.

public static return_type operator op (argument list)

Where the op is the operator to be overloaded and operator is the required keyword. For overloading the unary operators, there is only one argument and for overloading a binary operator there are two arguments. Remember that at least one of the arguments must be user-defined type such as class or struct type.

Overloading Unary Operators

The general form of operator function for unary operators is as follows.

public static return_type operator op (Type t) { // Statements }

Where Type must be a class or struct. The return_type can be any type except void for unary operators like +,~,! and dot (.). but the return_type must be the type of Type for ++ and remember that the true and false operators can be overloaded only as pairs. The compliation errors occurs if a class declares one of these operators without declaring the other.

The following program overloads the unary (-) operator inside the Base class.

/* Unary Operator Overloading */
using System;
class Base
{
  private int x;
  private int y;
  public Base(int i, int j)
  {
    x = i;
    y = j;
  }
  public void show()
  {
    Console.WriteLine("{0}{1}",x,y);
  }
  public static Base operator - (Base ob)
  {
    Base t = new Base();
    t.x = -b.x;
    t.y = -b.y;
    return t;
  }
}

class UnaryOpeOverloading
{
  public static void Main()
  {
    Base obj = new Base(10,20);    //display 10 and 20
    obj.show();
    Base obj2 = new Base();    //display 0 and 0
    obj2.show();
    obj2 = -obj;
    obj2.show();    //display -10 and -20
  }
}

Output

Overloading Binary Operators

An overloaded binary operator must take two arguments and at least one of them must be of the type class or struct, in which the operation in defined. But overloaded binary operators can return any value except the type void. The general form of an overloaded binary operator is as follows.

public static return_type operator op (Type t1, Type2 t2) { //Statement }

A concrete example is given below. This program overloads plus (+) operator to mean adding two complex numbers defined by class Base.

/* Binary Operator Overloading */
using System;
class Base
{
  private int x;
  private int y;
  public Base(int i, int j)
  {
    x = i;
    y = j;
  }
  public void show()
  {
    Console.WriteLine("{0}{1}",x,y);
  }
  public static Base operator + (Base ob, Base ob2)
  {
    Base t = new Base();
    t.x = ob.x + ob2.x;
    t.y = ob.y + ob2.y;
    return t;
  }
}

class BinaryOpeOverloading
{
  public static void Main()
  {
    Base obj = new Base(10,20);    //display 10 and 20
    obj.show();

    Base obj1 = new Base(20,30);    //display 20 and 30
    obj1.show();

    Base obj2 = new Base();
    obj2 = obj + obj1;    // + overload used
    obj2.show();    //display 30 and 50
  }
}

Output

Overloading Comparison Operators

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

/* Comparison Operator Overloading */
using System;
class Over
{
  public int a,b;
  public Over
  {
    a = 10;
    b = 20;
  }

  public Over(int x, int y)
  {
    a = x;
    b = y;
  }

  public void Show()
  {
    Console.WriteLine("A = "+a);
    Console.WriteLine("B = "+b);
  }

  public static bool operator > (Over o, Over o1)
  {
    if(o.a > o1.a && o.b > o1.b)
    {
      return true;
    }
    else
    {
      return false;
    }
  }

  public static bool operator > (Over o, Over o1)
  {
    if(o.a < o1.a && o.b < o1.b)
    {
      return true;
    }
    else
    {
      return false;
    }
  }
}

class ComparisonOpeOverloading
{
  public static void Main()
  {
    Over ob = new Over();
    ob.Show();

    Over obj1 = new Over(100,200);
    obj.Show();

    if(obj > obj1)
    {
      Console.WriteLine("First Object is Greater");
    }
    else
    {
      Console.WriteLine("Second Object is Greater");
    }
  }
}

Rules of Operator Overloading

While Overloading an operator, the following rules must be kept in mind.

The user defined operator declarations can't modify the syntax, precedence or associativity of an operator. For example, a + operator is always a binary operator having a predefined precedence and an associativity of left to right.
User defined operator implementations are given preference over prefefined implementations.
Operator overload methods can't return void.
The operator overload methods can be overloaded just like any other methods in C#. The overloaded methods shoult 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.