Indirectly Overloading the +=, -=, /=, and *= Operators -CodeIdol

Indirectly Overloading the +=, -=, /=, and *= Operators

Problem

You need to control the handling of the +=, -=, /=, and *= operators within your data type; unfortunately, these operators cannot be directly overloaded.

Solution

Overload these operators indirectly by overloading the +, -, /, and * operators, as demonstrated in Figure.

Overloading the +, -, /, and * operators

public class Foo 
{
    // Other class members…
    // Overloaded binary operators
    public static Foo operator +(Foo f1, Foo f2)
    {
       Foo result = new Foo( );
       // Add f1 and f2 here…
       // place result of the addition into the result variable.
       return (result);
    }
    public static Foo operator +(int constant, Foo f1)
    {
       Foo result = new Foo( );
       // Add the constant integer and f1 here…
       // place result of the addition into the result variable.
       return (result);
    }
    public static Foo operator +(Foo f1, int constant)
    {
       Foo result = new Foo( );
       // Add the constant integer and f1 here…
       // place result of the addition into the result variable.
       return (result);
    }
    public static Foo operator -(Foo f1, Foo f2)
    {
       Foo result = new Foo( );
       // Subtract f1 and f2 here…
       // place result of the subtraction into the result variable.
       return (result);
    }
    public static Foo operator -(int constant, Foo f1)
     {
       Foo result = new Foo( );
       // Subtract the constant integer and f1 here…
       // place result of the subtraction into the result variable.
       return (result);
     }
    public static Foo operator -(Foo f1, int constant)
     {
       Foo result = new Foo( );
       // Subtract the constant integer and f1 here…
       // place result of the subtraction into the result variable.
       return (result);
     }
     public static Foo operator *(Foo f1, Foo f2)
     {
       Foo result = new Foo( );
       // Multiply f1 and f2 here…
       // place result of the multiplication into the result variable.
       return (result);
    }
    ypublic static Foo operator *(int multiplier, Foo f1)
    {
       Foo result = new Foo( );
       // Multiply multiplier and f1 here…
       // place result of the multiplication into the result variable.
       return (result);
    }
    public static Foo operator *(Foo f1, int multiplier)
    {
       return (multiplier * f1);
    }
    public static Foo operator /(Foo f1, Foo f2)
    {
       Foo result = new Foo( );
       // Divide f1 and f2 here…
       // place result of the division into the result variable.
       return (result);
    }
    public static Foo operator /(int numerator, Foo f1)
    {
       Foo result = new Foo( );
       // Divide numerator and f1 here…
       // place result of the division into the result variable.
       return (result);
    }
    public static Foo operator /(Foo f1, int denominator)
    { 
       return (1 / (denominator / f1)); 
    }
}

Discussion

While it is illegal to overload the +=, -=, /=, and *= operators directly, you can overload them indirectly by overloading the +, -, /, and * operators. The +=, -=, /=, and *= operators use the overloaded +, -, /, and * operators for their calculations.

The four operators +, -, /, and * are overloaded by the methods in the Solution section of this recipe. You might notice that each operator is overloaded three times. This is intentional, since a user of your object may attempt to add, subtract, multiply, or divide it by an integer value. The unknown here is: which position will the integer constant be in? Will it be in the first parameter or the second? The following code snippet shows how this might look for multiplication:

	Foo x = new Foo( );
	Foo y = new Foo( );
	y *= 100;      // Uses: operator *(Foo f1, int multiplier) 
	y = 100 * x;    // Uses: operator *(int multiplier, Foo f1)
	y *= x;       // Uses: operator *(Foo f1, Foo f2)

The same holds true for the other overloaded operators.

If these operators were being implemented in a class, you would first check whether any were set to null. The following code for the overloaded addition operator has been modified to do this:

	public static Foo operator +(Foo f1, Foo f2)
	{
	   if (f1 == null)
	   {
	      throw (new ArgumentNullException("f1"));
	   }
	   else if (f2 == null)
	   {
	      throw (new ArgumentNullException("f2"));
	   }
	   else
	   {
	      Foo result = new Foo( );
	      // Add f1 and f2 here…
	      // place result of the addition into the result variable.
	      return (result);
	   }
	}

Sept. 13, 2009, 7:02 a.m.
posted by bert

Indirectly Overloading the +=, -=, /=, and *= Operators