11.8. Operator Overloading

Manipulations of class objects are accomplished by sending messages (in the form of method calls) to the objects. This method-call notation is cumbersome for certain kinds of classes, especially mathematical classes. For these classes, it would be convenient to use C#'s rich set of built-in operators to specify object manipulations. In this section, we show how to enable these operators to work with class objectsvia a process called operator overloading .

Software Engineering Observation 11.9 Use operator overloading when it makes an application clearer than accomplishing the same operations with explicit method calls.

C# enables you to overload most operators to make them sensitive to the context in which they are used. Some operators are overloaded frequently, especially the various arithmetic operators, such as + and - . The job performed by overloaded operators also can be performed by explicit method calls, but operator notation often is more natural. Figures 11.17 and 11.18 provide an example of using operator overloading with a ComplexNumber class.

Figure 11.17. Class that overloads operators for adding, subtracting and multiplying complex numbers .

1



// Fig. 11.17: ComplexNumber.cs



2



// Class that overloads operators for adding, subtracting



3



// and multiplying complex numbers.



4



using


System;

5


6



public class


ComplexNumber

7

{

8



private double


real;


// real component of the complex number



9



private double


imaginary;


// imaginary component of the complex number



10


11



// constructor



12



public


ComplexNumber(


double


a,


double


b )

13

{

14

real = a;

15

imaginary = b;

16

}


// end constructor



17


18



// return string representation of ComplexNumber



19



public override string


ToString()

20

{

21



return string


.Format(


"(  i)"


,

22

Real, ( Imaginary <




?


"-"


:


"+"


), Math.Abs( Imaginary ) );

23

}


// end method ToString



24


25



// read-only property that gets the real component



26



public double


Real

27

{

28



get



29

{

30



return


real;

31

}


// end get



32

}


// end property Real



33

34



// read-only property that gets the imaginary component



35



public double


Imaginary

36

{

37



get



38

{

39



return


imaginary;

40

}


// end get



41

}


// end property Imaginary



42


43



// overload the addition operator



44




public static


ComplexNumber


operator


+(


45


ComplexNumber x, ComplexNumber y )


46


{


47




return new


ComplexNumber( x.Real + y.Real,


48


x.Imaginary + y.Imaginary );


49


}


// end operator +




50


51



// overload the subtraction operator



52




public static


ComplexNumber


operator


-(


53


ComplexNumber x, ComplexNumber y )


54


{


55




return new


ComplexNumber( x.Real - y.Real,


56


x.Imaginary - y.Imaginary );


57


}


// end operator -




58


59



// overload the multiplication operator



60




public static


ComplexNumber


operator


*(


61


ComplexNumber x, ComplexNumber y )


62


{


63




return new


ComplexNumber(


64


x.Real * y.Real - x.Imaginary * y.Imaginary,


65


x.Real * y.Imaginary + y.Real * x.Imaginary );


66


}


// end operator *




67

}


// end class ComplexNumber

Figure 11.18. Overloading operators for complex numbers.

1



// Fig 11.18: OperatorOverloading.cs



2



// Overloading operators for complex numbers.



3



using


System;

4


5



public class


ComplexTest

6

{

7



public static void


Main(


string


[] args )

8

{

9



// declare two

variables

to store complex numbers



10



// to be entered by

user




11

ComplexNumber x, y;

12


13



// prompt the user to enter the first complex number



14

Console.Write(


"Enter the real part of complex number x: "


);

15



double


realPart = Convert.ToDouble( Console.ReadLine() );

16

Console.Write(

17



"Enter the imaginary part of complex number x: "


);

18



double


imaginaryPart = Convert.ToDouble( Console.ReadLine() );

19

x =


new


ComplexNumber( realPart, imaginaryPart );

20


21



// prompt the user to enter the second complex number



22

Console.Write(


"\nEnter the real part of complex number y: "


);

23

realPart = Convert.ToDouble( Console.ReadLine() );

24

Console.Write(

25



"Enter the imaginary part of complex number y: "


);

26

imaginaryPart = Convert.ToDouble( Console.ReadLine() );

27

y =


new


ComplexNumber( realPart, imaginaryPart );

28


29



// display the results of calculations with x and y



30

Console.WriteLine();

31


Console.WriteLine(


" +  = "


, x, y, x + y );


32


Console.WriteLine(


" -  = "


, x, y, x - y );


33


Console.WriteLine(


" *  = "


, x, y, x * y );


34

}


// end method Main



35

}


// end class ComplexTest

Enter the real part of complex number x:


2


Enter the imaginary part of complex number x:


4


Enter the real part of complex number y:


4


Enter the imaginary part of complex number y:


-2


(2 + 4i) + (4 - 2i) = (6 + 2i) (2 + 4i) - (4 - 2i) = (-2 + 6i) (2 + 4i) * (4 - 2i) = (16 + 12i)

Class ComplexNumber (Fig. 11.17) overloads the plus ( + ), minus ( - ) and multiplication ( * ) operators to enable programs to add, subtract and multiply instances of class ComplexNumber using common mathematical notation. Lines 89 declare instance variables for the real and imaginary parts of the complex number.

Lines 4449 overload the plus operator ( + ) to perform addition of ComplexNumber s. Keyword operator , followed by an operator symbol, indicates that a method overloads the specified operator. Methods that overload binary operators must take two arguments. The first argument is the left operand, and the second argument is the right operand. Class ComplexNumber 's overloaded plus operator takes two ComplexNumber references as arguments and returns a ComplexNumber that represents the sum of the arguments. Note that this method is marked public and static , which is required for overloaded operators. The body of the method (lines 4748) performs the addition and returns the result as a new ComplexNumber . Notice that we do not modify the contents of either of the original operands passed as arguments x and y . This matches our intuitive sense of how this operator should behaveadding two numbers does not modify either of the original numbers. Lines 5266 provide similar overloaded operators for subtracting and multiplying ComplexNumber s.

Software Engineering Observation 11.10 Overload operators to perform the same function or similar functions on class objects as the operators perform on objects of simple types. Avoid non-intuitive use of operators.

Software Engineering Observation 11.11 At least one argument of an overloaded operator method must be a reference to an object of the class in which the operator is overloaded. This prevents programmers from changing how operators work on simple types.

Class ComplexTest (Fig. 11.18) demonstrates the overloaded operators for adding, subtracting and multiplying ComplexNumber s. Lines 1427 prompt the user to enter two complex numbers, then use this input to create two ComplexNumber s and assign them to variables x and y .

Lines 3133 add, subtract and multiply x and y with the overloaded operators, then output the results. In line 31, we perform the addition by using the plus operator with ComplexNumber operands x and y . Without operator overloading, the expression x + y would not make sensethe compiler would not know how two objects should be added. This expression makes sense here because we've defined the plus operator for two ComplexNumber s in lines 4449 of Fig. 11.17. When the two ComplexNumber s are "added" in line 31 of Fig. 11.18, this invokes the operator+ declaration, passing the left operand as the first argument and the right operand as the second argument. When we use the subtraction and multiplication operators in lines 3233, their respective overloaded operator declarations are invoked similarly.

Notice that the result of each calculation is a reference to a new ComplexNumber object. When this new object is passed to the Console class's WriteLine method, its ToString method (lines 1923 of Fig. 11.17) is implicitly invoked. We do not need to assign an object to a reference-type variable to invoke its ToString method. Line 31 of Fig. 11.18 could be rewritten to explicitly invoke the ToString method of the object created by the overloaded plus operator, as in:

Console.WriteLine(


" +  = "


, x, y, ( x + y ).ToString() );