12.1. Using the operator KeywordIn C#, operators are static methods . The return value of an operator represents the result of an operation. The operator's parameters are the operands. Thus, to create an addition operator for a Fraction class, you use the C# syntax of combining the operator keyword with the plus sign (+) operator combined with the keyword static . For example, the overloaded addition operator (the operator+ method) takes two Fraction objects (the fractions you want to add) as parameters and returns a reference to another Fraction object representing the sum of the two parameters. Here is its signature: public static Fraction operator+(Fraction lhs, Fraction rhs) And here's what you can do with it. Assume, for instance, you've defined two fractions representing the portion of a pie you've eaten for breakfast and lunch , respectively. (You love pie.) Fraction pieIAteForBreakfast = new Fraction(1,2); // 1/2 of a pie Fraction pieIAteForLunch = new Fraction(1,3); // 1/3 of a pie The overloaded operator+ allows you to figure out how much pie you've eaten in total. (And there's still 1/6 of a pie left over for dinner!) You write: Fraction totalPigOut = pieIAteForBreakfast + pieIAteForLunch; The compiler takes the first operand ( pieIAteForBreakfast ) and passes it to operator+ as the parameter lhs ; it passes the second operand ( pieIAteForLunch ) as rhs . These two Fractions are then added, and the result is returned and assigned to the Fraction object named totalPigOut .
To see how this works, you'll create a Fraction class, as described previously. The complete listing is shown in Example 12-1, followed by a detailed analysis. Example 12-1. Implementing operator+ for Fraction
The output looks like this: firstFraction: 3/4 secondFraction: 2/4 firstFraction + secondFraction = sumOfTwoFractions: 5/4 In Example 12-1, you start by creating a Fraction class. The private member data is the numerator and denominator , stored as integers: public class Fraction { private int numerator; private int denominator; The constructor just initializes these values. The overloaded addition operator takes two Fraction objects, returns a Fraction , and is marked static : public static Fraction operator+(Fraction lhs, Fraction rhs) { If the denominators for the fractions are the same, you add the numerators and return a new Fraction object created by passing in the sum of the numerators as the new numerator and the shared denominator as the new denominator: if (lhs.denominator == rhs.denominator) { return new Fraction(lhs.numerator+rhs.numerator, lhs.denominator); } The Fraction objects firstFraction and secondFraction are passed in to the overloaded addition operator as lhs and rhs , respectively. The new Fraction is created on the heap, and a reference is returned to the calling method, Run( ) , where it is assigned to sumOfTwoFractions : Fraction sumOfTwoFractions = firstFraction + secondFraction; Console.WriteLine( "firstFraction + secondFraction = sumOfTwoFractions: {0}", sumOfTwoFractions.ToString( ) ); Back in the implementation of the operator, if the denominators are different, you cross-multiply before adding. This allows you to add like Fractions . int firstProduct = lhs.numerator * rhs.denominator; int secondProduct = rhs.numerator * lhs.denominator; return new Fraction( firstProduct + secondProduct, lhs.denominator * rhs.denominator ); The two local variables , firstProduct and secondProduct , are temporary; they are destroyed when the method returns. The new Fraction created, however, is not temporary; it is created on the heap, and a reference is returned as previously.
The Fraction class overrides the ToString( ) method (inherited from Object ) to allow you to display the fractions by passing them to Console.WriteLine( ) . (For more information about overloading methods, see Chapter 8.) |