How Operators Work

To understand how to overload operators, it’s quite useful to think about what happens when the compiler encounters an operator. Using the addition operator (+) as an example, suppose that the compiler processes the following lines of code:

int myInteger = 3;
uint myUnsignedInt = 2;
double myDouble = 4.0;
long myLong = myInteger + myUnsignedInt;
double myOtherDouble = myDouble + myInteger;

What happens when the compiler encounters the following line?

long myLong = myInteger + myUnsignedInt;

The compiler identifies that it needs to add two integers and assign the result to a long. However, the expression myInteger + myUnsignedInt is really just an intuitive and convenient syntax for calling a method that adds two numbers together. The method takes two parameters, myInteger and myUnsignedInt, and returns their sum. Therefore, the compiler does the same thing as it does for any method call. It looks for the best matching overload of the addition operator based on the parameter types; in this case, one that takes two integers. As with normal overloaded methods, the desired return type does not influence the compiler’s choice as to which version of a method it calls. As it happens, the overload called in the example takes two int parameters and returns an int; this return value is subsequently converted to a long.

The next line causes the compiler to use a different overload of the addition operator:

double myOtherDouble = myDouble + myInteger;

In this instance, the parameters are a double and an int, but as it happens there isn’t an overload of the addition operator that takes this combination of parameters. Instead, the compiler identifies the best matching overload of the addition operator as being the version that takes two doubles as its parameters, and implicitly casts the int to a double. Adding two doubles requires a different process than adding two integers. Floating-point numbers are stored as a mantissa and an exponent. Adding them involves bit-shifting the mantissa of one of the doubles so that the two exponents have the same value, adding the mantissas, then shifting the mantissa of the result and adjusting its exponent to maintain the highest possible accuracy in the answer.

Now, you’re in a position to see what happens if the compiler finds something like this:

Vector vect1, vect2, vect3;
// initialize vect1 and vect2
vect3 = vect1 + vect2;
vect1 = vect1*2;

Here, Vector is the struct, which is defined in the following section. The compiler will see that it needs to add two Vector instances, vect1 and vect2, together. It’ll look for an overload of the addition operator, which takes two Vector instances as its parameters.

If the compiler finds an appropriate overload, it’ll call up the implementation of that operator. If it can’t find one, it’ll look to see if there is any other overload for + that it can use as a best match - perhaps something that has two parameters of other data types that can be implicitly converted to Vector instances. If the compiler can’t find a suitable overload, it’ll raise a compilation error, just as it would if it couldn’t find an appropriate overload for any other method call.

Operator Overloading Example: The Vector Struct

This section demonstrates operator overloading through developing a struct named Vector that represents a 3-dimensional mathematical vector. Don’t worry if mathematics is not your strong point - we’ll keep the vector example very simple. As far as you are concerned, a 3D-vector is just a set of three numbers (doubles) that tell you how far something is moving. The variables representing the numbers are called x, y, and z: x tells you how far something moves east, y tells you how far it moves north, and z tells you how far it moves upward (in height). Combine the three numbers and you get the total movement. For example, if x=3.0, y=3.0, and z=1.0 (which you’d normally write as (3.0, 3.0, 1.0), you’re moving 3 units East, 3 units North, and rising upward by 1 unit.

You can add or multiply vectors by other vectors or by numbers. Incidentally, in this context, we use the term scalar, which is math-speak for a simple number - in C# terms that’s just a double. The significance of addition should be clear. If you move first by the vector (3.0, 3.0, 1.0) then you move by the vector (2.0, -4.0, -4.0), the total amount you have moved can be worked out by adding the two vectors. Adding vectors means adding each component individually, so you get (5.0, -1.0, -3.0). In this context, mathematicians write c=a+b, where a and b are the vectors and c is the resulting vector. You want to be able to use the Vector struct the same way.

The following is the definition for Vector - containing the member fields, constructors, and a ToString() override so you can easily view the contents of a Vector, and finally that operator overload:

namespace Wrox.ProCSharp.OOCSharp
{
   struct Vector
   {
      public double x, y, z;

      public Vector(double x, double y, double z)
      {
         this.x = x;
         this.y = y; 
         this.z = z;
      }

      public Vector(Vector rhs)
      {
         x = rhs.x;
         y = rhs.y;
         z = rhs.z;
      }

      public override string ToString()
      {
         return "( " + x + " , " + y + " , " + z + " )";
      }

This example has two constructors that require the initial value of the vector to be specified, either by passing in the values of each component or by supplying another Vector whose value can be copied. Constructors like the second one that takes single Vector argument are often termed copy constructors, because they effectively allow you to initialize a class or struct instance by copying another instance. Note that to keep things simple, the fields are left as public. We could have made them private and written corresponding properties to access them, but it wouldn’t have made any difference to the example, other than to make the code longer.

Here is the interesting part of the Vector struct - the operator overload that provides support for the addition operator:

      public static Vector operator + (Vector lhs, Vector rhs)
      {
         Vector result = new Vector(lhs);
         result.x += rhs.x;
         result.y += rhs.y;
         result.z += rhs.z;

         return result;
      }
   }
}

The operator overload is declared in much the same way as a method, except the operator keyword tells the compiler it’s actually an operator overload you’re defining. The operator keyword is followed by the actual symbol for the relevant operator, in this case the addition operator (+). The return type is whatever type you get when you use this operator. Adding two vectors results in a vector, therefore, the return type is also a Vector. For this particular override of the addition operator, the return type is the same as the containing class, but that’s not necessarily the case as you see later in this example. The two parameters are the things you’re operating on. For binary operators (those that take two parameters), like the addition and subtraction operators, the first parameter is the value on the left of the operator, and the second parameter is the value on the right.

C# requires that all operator overloads be declared as public and static, which means that they are associated with their class or struct, not with a particular instance. Because of this, the body of the operator overload has no access to nonstatic class members and has no access to the this identifier. This is fine because the parameters provide all the input data the operator needs to know to perform its task.

Now that you understand the syntax for the addition operator declaration, you can look at what happens inside the operator:

{
   Vector result = new Vector(lhs);
   result.x += rhs.x;
   result.y += rhs.y;
   result.z += rhs.z;

   return result;
}

This part of the code is exactly the same as if you were declaring a method, and you should easily be able to convince yourself that this really will return a vector containing the sum of lhs and rhs as defined. You simply add the members x, y, and z together individually.

Now all you need to do is write some simple code to test the Vector struct. Here it is:

static void Main()
{
   Vector vect1, vect2, vect3;

   vect1 = new Vector(3.0, 3.0, 1.0);
   vect2 = new Vector(2.0, -4.0, -4.0);
   vect3 = vect1 + vect2;

   Console.WriteLine("vect1 = " + vect1.ToString());
   Console.WriteLine("vect2 = " + vect2.ToString());
   Console.WriteLine("vect3 = " + vect3.ToString());
}

Saving this code as Vectors.cs and compiling and running it returns this result:

Vectors

vect1 = ( 3 , 3 , 1 )
vect2 = ( 2 , -4 , -4 )
vect3 = ( 5 , -1 , -3 )

public static Vector operator * (double lhs, Vector rhs)
{
   return new Vector(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
}

b = 2 * a;

b = a * 2;

public static Vector operator * (Vector lhs, double rhs)
{
   return new Vector(rhs * lhs.x, rhs * lhs.y, rhs *lhs.z);
}

public static Vector operator * (Vector lhs, double rhs)
{
   return rhs * lhs;
}

public static double operator * (Vector lhs, Vector rhs)
{
   return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
}

static void Main()
{
   // stuff to demonstrate arithmetic operations
   Vector vect1, vect2, vect3;
   vect1 = new Vector(1.0, 1.5, 2.0);
   vect2 = new Vector(0.0, 0.0, -10.0);

   vect3 = vect1 + vect2;

   Console.WriteLine("vect1 = " + vect1);
   Console.WriteLine("vect2 = " + vect2);
   Console.WriteLine("vect3 = vect1 + vect2 = " + vect3);
   Console.WriteLine("2*vect3 = " + 2*vect3);

   vect3 += vect2;

   Console.WriteLine("vect3+=vect2 gives " + vect3);

   vect3 = vect1*2;

   Console.WriteLine("Setting vect3=vect1*2 gives " + vect3);

   double dot = vect1*vect3;

   Console.WriteLine("vect1*vect3 = " + dot);
}

vect1 = ( 1 , 1.5 , 2 )
vect2 = ( 0 , 0 , -10 )
vect3 = vect1 + vect2 = ( 1 , 1.5 , -8 )
2*vect3 = ( 2 , 3 , -16 )
vect3+=vect2 gives ( 1 , 1.5 , -18 )
Setting vect3=vect1*2 gives ( 2 , 3 , 4 )
vect1*vect3 = 14.5

vect3 += vect2;

Console.WriteLine("vect3 += vect2 gives " + vect3);

public static bool operator == (Vector lhs, Vector rhs)
{
   if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)
      return true;
   else
      return false;
}

public static bool operator != (Vector lhs, Vector rhs)
{
   return ! (lhs == rhs);
}

static void Main()
{
   Vector vect1, vect2, vect3;

   vect1 = new Vector(3.0, 3.0, -10.0);
   vect2 = new Vector(3.0, 3.0, -10.0);
   vect3 = new Vector(2.0, 3.0, 6.0);

   Console.WriteLine("vect1==vect2 returns  " + (vect1==vect2));
   Console.WriteLine("vect1==vect3 returns  " + (vect1==vect3));
   Console.WriteLine("vect2==vect3 returns  " + (vect2==vect3));

   Console.WriteLine();

   Console.WriteLine("vect1!=vect2 returns  " + (vect1!=vect2));
   Console.WriteLine("vect1!=vect3 returns  " + (vect1!=vect3));
   Console.WriteLine("vect2!=vect3 returns  " + (vect2!=vect3));
}

Microsoft (R) Visual C# 2009 Compiler version 8.00.50727.42
for Microsoft (R) Windows (R) 2009 Framework version 2.0.50727
Copyright (C) Microsoft Corporation 2001-2009. All rights reserved.


Vectors3.cs(5,11): warning CS0660: 'Wrox.ProCSharp.OOCSharp.Vector' defines
        operator == or operator != but does not override Object.Equals(object o)
Vectors3.cs(5,11): warning CS0661: 'Wrox.ProCSharp.OOCSharp.Vector' defines
        operator == or operator != but does not override Object.GetHashCode()

vect1==vect2 returns  True
vect1==vect3 returns  False
vect2==vect3 returns  False

vect1!=vect2 returns  False
vect1!=vect3 returns  True
vect2!=vect3 returns  True

Which Operators Can You Overload?

It is not possible to overload all of the available operators. The operators that you can overload are listed in the following table.

Open table as spreadsheet

Category	Operators	Restrictions
Arithmetic binary	+, *, /, –, %	None.
Arithmetic unary	+, –, ++, – –	None.
Bitwise binary	&, |, ^, <<, >>	None.
Bitwise unary	!, ~ true, false	The true and false operators must be overloaded as a pair.
Comparison	==, !=, >=, <= >, <,	Comparison operators must be overloaded in pairs.
Assignment	+=, –=, *=, /=, >>=, <<=, %=, &=, |=, ^=	You cannot explicitly overload these operators; they are over ridden implicitly when you override the individual operators such as +, –, %, and so on.
Index	[]	You cannot overload the index operator directly. The indexer member type, discussed in Chapter 2, “C# Basics,” allows you to support the index operator on your classes and structs.
Cast	()	You cannot overload the cast operator directly. User-defined casts (discussed next) allow you to define custom cast behavior.