12
Operator Overloading
Let’s explain what operator overloading is all about with an
example of a class that represents a date. Would it not be great if we could
subtract two date objects and be returned an int representing the number of
days elapsing between the two dates. We would like to use the good old
subtraction operator – like we do when subtracting numbers. Also we would like
the > operator to compare two date
objects and tell us which one is larger. The + operator could add a number to a
date resulting in a new date object.
Thus, operator overloading lets us redefine the existing
operators so that they work with classes/objects we create like yyy. We have
not yet instructed C# on how to use the trusty old + operator with two yyy
objects. Though C# knows how to use the + to add two numbers, it does not know
how to add two yyy’s.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c;
c = a + b ;
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
}
Compiler Error
a.cs(8,5): error CS0019: Operator ‘+’ cannot be applied to
operands of type ‘yyy’ and ‘yyy’
We have created a simple class yyy which has one instance
variable i which will distinguish different instances of yyy from each other.
The constructor with an int as a parameter initializes i. We have tried to add
two objects that look like yyy which does not go down well with C# and it
objects to it.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c;
c = a + b ;
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public yyy operator + ( yyy x , yyy y)
{
}
}
Compiler Error
a.cs(18,12): error CS0558: User-defined operators
‘yyy.operator +(yyy, yyy)’ must be declared static and public
Error messages can be at times helpful. Our operator + is
public but not static. C# demands that all operator overloads be static.
a.cs
public class zzz
{
public static void Main() {
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c;
c = a + b ;
System.Console.WriteLine(c.i);
}
}
public class yyy
{
public int i;
public yyy( int j) {
i = j;
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
}
Output
operator + 10 5
15
The word operator as the name of a function, is legal and
the only way to overload operators. We follow this word with the operator we
want to overload and then the parameters we will call the operator with. + is a
binary operator and will need two yyy’s, one on its left and the other on its right. Then at beginning, we give the return value of the operator. In
our case we want a + to add two yyy’s and return a third yyy whose i will be
the sum of the individual i’s. Thus a+b will call the operator + with x being
equal to a and y to b. Thus x.i will have a value 10 and y.i, 5. We are
creating a new object z and in the constructor passing 15 i.e. 10 + 5. Thus the
i of z will be 15 which is being returned. a + b will now be replaced by the
object whose i has a value 15 and c will be equal to this object. Thus c.i will
be equal to 15.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c;
c = a + b ;
System.Console.WriteLine(c.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static yyy operator = ( yyy x , yyy y)
{
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
}
Compiler Error
a.cs(19,28): error CS1020: Overloadable binary operator
expected
The error message is telling us that we cannot overload the
assignment operator =. Every class gets a free assignment operator which does a
bitwise copy of the variables of the object from the left to the right.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy c = new yyy(2);
yyy d;
d = a + b + c ;
System.Console.WriteLine(d.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
}
Output
Operator + 10 5
Operator + 15 2
17
The only change is d = a + b + c. C# gets easily confused
with complex statements so it does not read all of it. It sees two operators on
the same line. In this case, the same plus. An internal rule tells it to read
the plus left to right i.e. it will only see a + b. It will call the operator +
with x.i as 10 and y.i as 5 because a’s i is 10 and b’s i is 5. This will
create a temporary object like yyy whose i is 15, lets call it zz. The object z
is very different from zz. C# then evaluates zz + c. Thus x.i will display 15
and y.i will have the value of c.i i.e. 2. To support multiple invocations of
the operator on a single line, the code does not change.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
int d = a + b ;
System.Console.WriteLine(d);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static int operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
return x.i + y.i;
}
}
Output
operator + 10 5
15
C# does not and will never understand what addition of two
yyy’s is all about. It is in your hands to decide what the code accomplishes.
You decide whether the overloaded + returns a yyy or an int object. The class
yyy is your creation not C#’s. Hence you decide what addition means in the
context of a yyy class. In this case, we are returning an int unlike earlier
where we returned a yyy.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
int d = a + b ;
System.Console.WriteLine(d);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static int operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
return x.i + y.i;
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
}
Compiler Error
a.cs(23,19): error CS0111: Class ‘yyy’ already defines a
member called ‘ op_Addition ‘ with the same parameter types
You cannot have two operator + overloads which only differ
in return types. Also the error messages change the name of the operator from +
to op_Addition. When we overloaded functions, the return type was not
considered part of the function signature. The same applies for operators.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy d = a + b + 20;
System.Console.WriteLine(d.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
}
Compiler Error
a.cs(7,9): error CS0019: Operator ‘+’ cannot be applied to
operands of type ‘yyy’ and ‘int’
C# is now telling you that you can add two yyy’s but cannot
do the same, i.e. add a yyy and an int as we have not told C# how to do so.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
yyy d = a + b + 20;
System.Console.WriteLine(d.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static yyy operator + ( yyy x , yyy y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y.i);
yyy z = new yyy(x.i+y.i);
return z;
}
public static yyy operator + ( yyy x , int y)
{
System.Console.WriteLine(“operator + “ + x.i + “ “ + y);
yyy z = new yyy(x.i+y);
return z;
}
}
Output
Operator + 10 5
Operator + 15 20
35
Life is fun in the fast lane. As we could have a large
number of functions with the same name but differing number of parameters,
ditto for operators. a + b as usual calls the first operator +. This as usual
creates a temp object, say zz and now
C# reads the line as zz + 20. This matches the second operator + which now gets
called. You can have over a million plus operators with differing parameters if
you desire.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
if ( a > b )
System.Console.WriteLine(“true”);
else
System.Console.WriteLine(“false”);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static bool operator > ( yyy x , yyy y)
{
System.Console.WriteLine(“operator < “ + x.i + “ “ + y.i);
return x.i > y.i;
}
}
Compiler Error
a.cs(20,20): error CS0216: The operator ‘yyy.operator
>(yyy, yyy)’ requires a matching operator ‘<‘ to also be defined
C# is a romantic at heart and loves pairs. We tried to
overload the > operator and C# tells us that we have to also overload the
< operator. It makes sense as a user would want to know whether a yyy is
greater than or less than another yyy.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
yyy b = new yyy(5);
if ( a > b )
System.Console.WriteLine(“true”);
else
System.Console.WriteLine(“false”);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static bool operator > ( yyy x , yyy y)
{
System.Console.WriteLine(“operator > “ + x.i + “ “ + y.i);
return x.i > y.i;
}
public static bool operator < ( yyy x , yyy y)
{
System.Console.WriteLine(“operator < “ + x.i + “ “ + y.i);
return x.i < y.i;
}
}
Output
operator > 10 5
true
The operator < returns a bool as we would like to use it
as part of an if or a while. In this case we are using it as part of an if and
nothing stops us from using the < overloaded for ints and yyy’s to return a
bool. What code you write in an operator is entirely your decision. The <
operator looks like the + and can take different parameters. To overload the
!=, you also have to overload the ==.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
System.Console.WriteLine(a);
System.Console.WriteLine(a.ToString());
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
}
Output
yyy
yyy
In the first WriteLine function to be called, we are passing
the object a whereas the first parameter to WriteLine should be a string. Also
we do not get an error and we see yyy displayed. A longtime back we told you
that all classes finally derive from object. The class object has a function
ToString. Thus calling the ToString function off a produces the same output as
the above line. We have not created the ToString function. So either we got a
free ToString implementation from C# like we get a free Constructor or the
ToString function of object in some way determines the name of our class and
returns it as a string.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
System.Console.WriteLine(a);
System.Console.WriteLine(a.ToString());
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Compiler Warning
a.cs(17,15): warning CS0114: ‘yyy.ToString()’ hides
inherited member ‘object.ToString()’. To make the current method override that
implementation, add the override keyword. Otherwise add the new keyword.
It is the same warning if a function exists in the base
class.
Output
yyy
ToString
mukhi
WriteLine displays yyy and a.ToString displays mukhi. Which
means that they call different ToString functions. The WriteLine(a) calls the
ToString of object whereas the second WriteLine calls it of yyy. If we want to
override a function in the base class, we have to specifically do so by using
the modifier override. If we do not, the default is to call the base class
ToString. All this has been explained earlier, in any case.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
System.Console.WriteLine(a);
System.Console.WriteLine(a.ToString());
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
ToString
mukhi
ToString
mukhi
Now both the System.Console.WriteLine calls the ToString
function of yyy. We would like to convert a yyy into a string or an int for
example. These type conversions are a major part of operator overloading.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
System.Console.WriteLine(a);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static implicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
operator string
string 10
In spite of having a function ToString, it does not get
called unlike earlier. After the keyword operator we have the name of a data
type i.e. string. This function is called whenever we want to convert our
object into a string. The parameter y stands for the object to be converted. In
this function we can write whatever code we want to but we must return a
string. In our case we return the text string concatenated with the current
value of i.
Once again, the WriteLine function requires a string class.
We are offering a yyy class. C# checks whether there is an operator string
which is available to convert a yyy into a string. As there is one, it gets
called. The word implicit means that we are indirectly implying that it should
be called. Lets explain this with another example.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
string s;
s = a;
System.Console.WriteLine(s);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static explicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Compiler Error
a.cs(7,5): error CS0029: Cannot implicitly convert type
‘yyy’ to ‘string’
We have changed the word implicit which means imply. It also
means giving a hint with the word explicit which means specify. Had we not
changed implicit with explicit, we would have got no error and C# would have
called the operator to convert a into a string and initialize s to it.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
string s;
s = (string)a;
System.Console.WriteLine(s);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static explicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
operator string
string 10
The () is called a cast and it takes any data type within
brackets. We are explicitly asking for a conversion to a string and unlike
earlier we are not being implicit but explicit.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
string s;
s = (string)a;
System.Console.WriteLine(s);
System.Console.WriteLine(a);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static explicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
operator string
string 10
ToString
mukhi
The explicit will get called only when we cast and as we do
not have an implicit modifier, the ToString gets called. We get no error if we
do not have an implicit modifier.
a.cs
public class zzz
{
public static void Main()
{
yyy a = new yyy(10);
string s;
s = (string)a;
System.Console.WriteLine(s);
System.Console.WriteLine(a);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public static explicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public static implicit operator string(yyy y)
{
System.Console.WriteLine(“operator string”);
return “string “ + y.i;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Compiler Error
a.cs(24,15): error CS0557: Duplicate user-defined conversion
in class ‘yyy’
We cannot have both the implicit and explicit modifier as
two separate functions. Thus you have to decide which one you would want to
implement.
a.cs
public class zzz
{
public static void Main()
{
yyy a ;
a = 10;
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
a.cs(7,5): error CS0029: Cannot implicitly convert type
‘int’ to ‘yyy’
One more error. Here we are trying to equate a yyy to an int
but unlike earlier, we have not created an object like yyy by saying new. We
would need someone to create the yyy object and initialize it to 10, an int.
a.cs
public class zzz
{
public static void Main()
{
yyy a ;
a = 10;
System.Console.WriteLine(a.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
static public implicit operator yyy(int v)
{
System.Console.WriteLine(“operator yyy int “ + v);
yyy z = new yyy(v);
return z;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
operator yyy int 10
10
A constructor has the same name as the name of the class.
Thus operator yyy may double up as a constructor. When we write a = 10, C#
calls this constructor and passes the parameter v a value, 10. Operator yyy has
now to create an object that looks like yyy and return it. Thus it does not act
like a constructor in the sense that a constructor is responsible for creating the object. In other words, writing a
= 10, creates a new object that looks like yyy and initializes it to 10. It is
different from what we did earlier as previously the operator did not have to
create an object that looks like yyy. In this case it has to.
a.cs
public class zzz
{
public static void Main()
{
yyy a ;
a = “Hi”;
System.Console.WriteLine(a.i);
}
}
public class yyy
{
public int i;
public yyy( int j)
{
i = j;
}
static public implicit
operator yyy(int v)
{
System.Console.WriteLine(“operator yyy int “ + v);
yyy z = new yyy(v);
return z;
}
static public implicit
operator yyy(string v)
{
System.Console.WriteLine(“operator yyy string “ + v);
yyy z = new yyy(100);
return z;
}
public override string ToString()
{
System.Console.WriteLine(“ToString”);
return “mukhi”;
}
}
Output
operator yyy string Hi
100
We can have as many operator yyy functions as we like,
provided we follow the rules of function overloading. Thus we have two of them,
one that takes a string, another that takes an int. In this case as we are
writing a = “hi”, the second operator that accepts a string get called. They
all have to return an object that looks like yyy.
a = (short) 10;
Had we written the above line, we will not get any errors. We assumed we will get an error as we do not have an operator yyy which takes a short as a parameter. C# is highly intelligent. It first checks whether we have an operator yyy that matches what we wrote. In no case, there is a match. It will then check whether there is any other way it can prevent an error from being signaled. C# realizes that there is an operator yyy which accepts an int. Thus it converts a short to an int and then calls the operator yyy with the int parameter.