304 Operator Overloading, Friends, and References Display 8.1 Operator Overloading (part 1 of 5) 1 #include <iostream> 2 #include <cstdlib> 3 #include <cmath> 4 using namespace std; 5 //Class for amounts of money in U.S. currency 6 class Money 7 { 8 public: 9 Money( ); 10 Money(double amount); 11 Money(int theDollars, int theCents); 12 Money(int theDollars); 13 double getAmount( ) const; 14 int getDollars( ) const; 15 int getCents( ) const; 16 void input( ); //Reads the dollar sign as well as the amount number. 17 void output( ) const; 18 private: 19 int dollars; //A negative amount is represented as negative dollars and 20 int cents; //negative cents. Negative $4.50 is represented as -4 and -50. 21 int dollarsPart(double amount) const; 22 int centsPart(double amount) const; 23 int round(double number) const; 24 }; 25 const Money operator +(const Money& amount1, const Money& amount2); 26 const Money operator -(const Money& amount1, const Money& amount2); 27 bool operator ==(const Money& amount1, const Money& amount2); 28 const Money operator -(const Money& amount); 29 int main( ) 30 { 31 Money yourAmount, myAmount(10, 9); 32 cout << "Enter an amount of money: "; 33 yourAmount.input( ); 34 cout << "Your amount is "; 35 yourAmount.output( ); 36 cout << endl; 37 cout << "My amount is "; 38 myAmount.output( ); 39 cout << endl; This is a unary operator and is discussed in the subsection OO OO vv vv ee ee rr rr ll ll oo oo aa aa dd dd ii ii nn nn gg gg UU UU nn nn aa aa rr rr yy yy OO OO pp pp ee ee rr rr aa aa tt tt oo oo rr rr ss ss For an explanation of a const on a returned type see the subsection RR RR ee ee tt tt uu uu rr rr nn nn ii ii nn nn gg gg bb bb yy yy const VV VV aa aa ll ll uu uu ee ee . 08_CH08.fm Page 304 Wednesday, August 13, 2003 1:02 PM Basic Operator Overloading 305 Display 8.1 Operator Overloading (part 2 of 5) 40 if (yourAmount == myAmount) 41 cout << "We have the same amounts.\n"; 42 else 43 cout << "One of us is richer.\n"; 44 Money ourAmount = yourAmount + myAmount; 45 yourAmount.output( ); cout << " + "; myAmount.output( ); 46 cout << " equals "; ourAmount.output( ); cout << endl; 47 Money diffAmount = yourAmount - myAmount; 48 yourAmount.output( ); cout << " - "; myAmount.output( ); 49 cout << " equals "; diffAmount.output( ); cout << endl; 50 return 0; 51 } 52 const Money operator +(const Money& amount1, const Money& amount2) 53 { 54 int allCents1 = amount1.getCents( ) + amount1.getDollars( )*100; 55 int allCents2 = amount2.getCents( ) + amount2.getDollars( )*100; 56 int sumAllCents = allCents1 + allCents2; 57 int absAllCents = abs(sumAllCents); //Money can be negative. 58 int finalDollars = absAllCents/100; 59 int finalCents = absAllCents%100; 60 if (sumAllCents < 0) 61 { 62 finalDollars = -finalDollars; 63 finalCents = -finalCents; 64 } 65 return Money(finalDollars, finalCents); 66 } 67 //Uses cstdlib: 68 const Money operator -(const Money& amount1, const Money& amount2) 69 { 70 int allCents1 = amount1.getCents( ) + amount1.getDollars( )*100; 71 int allCents2 = amount2.getCents( ) + amount2.getDollars( )*100; 72 int diffAllCents = allCents1 - allCents2; 73 int absAllCents = abs(diffAllCents); 74 int finalDollars = absAllCents/100; 75 int finalCents = absAllCents%100; 76 if (diffAllCents < 0) 77 { 78 finalDollars = -finalDollars; Note that we need to use accessor and mutator functions. If the return statements puzzle you, see the tip entitled AA AA CC CC oo oo nn nn ss ss tt tt rr rr uu uu cc cc tt tt oo oo rr rr CC CC aa aa nn nn RR RR ee ee tt tt uu uu rr rr nn nn aa aa nn nn OO OO bb bb jj jj ee ee cc cc tt tt . 08_CH08.fm Page 305 Wednesday, August 13, 2003 1:02 PM 306 Operator Overloading, Friends, and References Display 8.1 Operator Overloading (part 3 of 5) 79 finalCents = -finalCents; 80 } 81 return Money(finalDollars, finalCents); 82 } 83 bool operator ==(const Money& amount1, const Money& amount2) 84 { 85 return ((amount1.getDollars( ) == amount2.getDollars( )) 86 && (amount1.getCents( ) == amount2.getCents( ))); 87 } 88 const Money operator -(const Money& amount) 89 { 90 return Money(-amount.getDollars( ), -amount.getCents( )); 91 } 92 Money::Money( ): dollars(0), cents(0) 93 {/*Body intentionally empty.*/} 94 Money::Money(double amount) 95 : dollars(dollarsPart(amount)), cents(centsPart(amount)) 96 {/*Body intentionally empty*/} 97 Money::Money(int theDollars) 98 : dollars(theDollars), cents(0) 99 {/*Body intentionally empty*/} 100 101 //Uses cstdlib: 102 Money::Money(int theDollars, int theCents) 103 { 104 if ((theDollars < 0 && theCents > 0) || (theDollars > 0 && theCents < 0)) 105 { 106 cout << "Inconsistent money data.\n"; 107 exit(1); 108 } 109 dollars = theDollars; 110 cents = theCents; 111 } 112 double Money::getAmount( ) const 113 { 114 return (dollars + cents*0.01); 115 } 116 int Money::getDollars( ) const If you prefer, you could make these short constructor definitions inline function definitions as discussed in Chapter 7. 08_CH08.fm Page 306 Wednesday, August 13, 2003 1:02 PM Basic Operator Overloading 307 Display 8.1 Operator Overloading (part 4 of 5) 117 { 118 return dollars; 119 } 120 int Money::getCents( ) const 121 { 122 return cents; 123 } 124 //Uses iostream and cstdlib: 125 void Money::output( ) const 126 { 127 int absDollars = abs(dollars); 128 int absCents = abs(cents); 129 if (dollars < 0 || cents < 0)//accounts for dollars == 0 or cents == 0 130 cout << "$-"; 131 else 132 cout << ’$’; 133 cout << absDollars; 134 135 if (absCents >= 10) 136 cout << ’.’ << absCents; 137 else 138 cout << ’.’ << ’0’ << absCents; 139 } 140 //Uses iostream and cstdlib: 141 void Money::input( ) 142 { 143 char dollarSign; 144 cin >> dollarSign; //hopefully 145 if (dollarSign != ’$’) 146 { 147 cout << "No dollar sign in Money input.\n"; 148 exit(1); 149 } 150 double amountAsDouble; 151 cin >> amountAsDouble; 152 dollars = dollarsPart(amountAsDouble); 153 cents = centsPart(amountAsDouble); 154 } 155 int Money::dollarsPart(double amount) const 156 < The rest of the definition is the same as BankAccount::dollarsPart in Display 7.2. > For a better definition of the input function, see Self-Test Exercise 3 in Chapter 7. 08_CH08.fm Page 307 Wednesday, August 13, 2003 1:02 PM 308 Operator Overloading, Friends, and References Tip If you look at the main function in the demonstration program in Display 8.1, you will see that the overloaded binary operators +, -, and == are used with objects of the class Money in the same way that +, -, and == are used with the predefined types, such as int and double. You can overload most but not all operators. One major restriction on overloading an operator is that at least one operand must be of a class type. So, for example, you can overload the % operator to apply to two objects of type Money or to an object of type Money and a double, but you cannot overload % to combine two doubles. A C ONSTRUCTOR C AN R ETURN AN O BJECT We often think of a constructor as if it were a void function. However, constructors are special functions with special properties, and sometimes it makes more sense to think of them as return- Display 8.1 Operator Overloading (part 5 of 5) 157 int Money::centsPart(double amount) const 158 < The rest of the definition is the same as BankAccount::centsPart in Display 7.2. > 159 int Money::round(double number) const 160 < The rest of the definition is the same as BankAccount::round in Display 7.2. > S AMPLE D IALOGUE Enter an amount of money: $123.45 Your amount is $123.45 My amount is $10.09. One of us is richer. $123.45 + $10.09 equals $133.54 $123.45 - $10.09 equals $113.36 O PERATOR O VERLOADING A (binary) operator, such as +, -, /, %, and so forth, is simply a function that is called using a dif- ferent syntax for listing its arguments. With a binary operator, the arguments are listed before and after the operator; with a function the arguments are listed in parentheses after the function name. An operator definition is written similar to a function definition, except that the operator definition includes the reserved word operator before the operator name. The predefined oper- ators, such as +, -, and so forth, can be overloaded by giving them a new definition for a class type. An example of overloading the +, -, and == operators is given in Display 8.1. 08_CH08.fm Page 308 Wednesday, August 13, 2003 1:02 PM Basic Operator Overloading 309 Self-Test Exercises ing a value. Notice the return statement in the definition of the overloaded + operator in Display 8.1, which we repeat below: return Money(finalDollars, finalCents); The expression that is returned is an invocation of the constructor for Money. Although we some- times think of a constructor as a void function, a constructor constructs an object and can also be thought of as returning an object of the class. If you feel uncomfortable with this use of the constructor, it may help to know that this return statement is equivalent to the following, more cumbersome and less efficient, code: Money temp; temp = Money(finalDollars, finalCents); return temp; An expression, such as Money(finalDollars, finalCents), is sometimes called an aa aa nn nn oo oo nn nn yy yy mm mm oo oo uu uu ss ss oo oo bb bb jj jj ee ee cc cc tt tt , since it is not named by any variable. However, it is still a full-fledged object. You can even use it as a calling object, as in the following: Money(finalDollars, finalCents).getDollars( ) The previous expression returns the int value of finalDollars. 1. What is the difference between a (binary) operator and a function? 2. Suppose you wish to overload the operator < so that it applies to the type Money defined in Display 8.1. What do you need to add to the definition of Money given in Display 8.1? 3. Is it possible using operator overloading to change the behavior of + on integers? Why or why not? ■ RETURNING BY const VALUE Notice the returned types in the declarations for overloaded operators for the class Money in Display 8.1. For example, the following is the declaration for the overloaded plus operator as it appears in Display 8.1: const Money operator +(const Money& amount1, const Money& amount2); This subsection explains the const at the start of the line. But before we discuss that first const, let’s make sure we understand all the other details about returning a value. So, let’s first consider the case where that const does not appear in either the declaration or anonymous object 08_CH08.fm Page 309 Wednesday, August 13, 2003 1:02 PM 310 Operator Overloading, Friends, and References definition of the overloaded plus operator. Let’s suppose that the declaration reads as follows: Money operator +(const Money& amount1, const Money& amount2); and let’s see what we can do with the value returned. When an object is returned, for example, (m1 + m2), where m1 and m2 are of type Money, the object can be used to invoke a member function, which may or may not change the value of the member variables in the object (m1 + m2). For example, (m1 + m2).output( ); is perfectly legal. In this case, it does not change the object (m1 + m2). However, if we omitted the const before the type returned for the plus operator, then the following would be legal and would change the values of the member variables of the object (m1 + m2): (m1 + m2).input( ); So, objects can be changed, even when they are not associated with any variable. One way to make sense of this is to note that objects have member variables and thus have some kinds of variables that can be changed. Now let’s assume that everything is as shown in Display 8.1; that is, there is a const before the returned type of each operator that returns an object of type Money. For example, below is the declaration for the overloaded plus operator as it appears in Dis- play 8.1: const Money operator +(const Money& amount1, const Money& amount2); The first const on the line is a new use of the const modifier. This is called returning a value as const or returning by const value or returning by constant value. What the const modifier means in this case is that the returned object cannot be changed. For example, consider the following code: Money m1(10.99), m2(23.57); (m1 + m2).output( ); The invocation of output is perfectly legal because it does not change the object (m1 + m2). However, with that const before the returned type, the following will pro- duce a compiler error message: (m1 + m2).input( ); Why would you want to return by const value? It provides a kind of automatic error checking. When you construct (m1 + m2), you do not want to inadvertently change it. At first this protection from changing an object may seem like too much protection, since you can have return by constant value 08_CH08.fm Page 310 Wednesday, August 13, 2003 1:02 PM Basic Operator Overloading 311 Money m3; m3 = (m1 + m2); and you very well may want to change m3. No problem—the following is perfectly legal: m3 = (m1 + m2); m3.input( ); The values of m3 and (m1 + m2) are two different objects. The assignment operator does not make m3 the same as the object (m1 + m2). Instead, it copies the values of the member variables of (m1 + m2) into the member variables of m3. With objects of a class, the default assignment operator does not make the two objects the same object, it only copies values of member variables from one object to another object. This distinction is subtle but important. It may help you understand the details if you recall that a variable of a class type and an object of a class type are not the same thing. An object is a value of a class type and may be stored in a variable of a class type, but the variable and the object are not the same thing. In the code m3 = (m1 + m2); the variable m3 and its value (m1 + m2) are different things, just as n and 5 are different things in int n = 5; or in int n = (2 + 3); It may take you a while to become comfortable with this notion of return by const value. In the meantime, a good rule of thumb is to always return class types by const value unless you have an explicit reason not to do so. For most simple programs this will have no effect on your program other than to flag some subtle errors. Note that although it is legal, it is pointless to return basic types, such as int, by const value. The const has no effect in the case of basic types. When a function or oper- ator returns a value of one of the basic types, such as int, double, or char, it returns the value, such as 5, 5.5, or ’A’. It does not return a variable or anything like a variable. 1 Unlike a variable, the value cannot be changed—you cannot change 5. Values of a basic type cannot be changed whether there is a const before the returned type or not. On the other hand, values of a class type—that is, objects—can be changed, since they have member variables, and so the const modifier has an effect on the object returned. 1 Unless the value returned is returned by reference, but return by reference is a topic covered later in this chapter. Here we assume the value is not returned by reference. 08_CH08.fm Page 311 Wednesday, August 13, 2003 1:02 PM 312 Operator Overloading, Friends, and References Tip R ETURNING M EMBER V ARIABLES OF A C LASS T YPE When returning a member variable of a class type, in almost all cases it is important to return the member value by const value. To see why, suppose you do not, as in the example outlined in what follows: class Employee { public: Money getSalary( ) { return salary; } . . . private: Money salary; . . . }; In this example, salary is a private member variable that should not be changeable except by using some accessor function of the class Employee. However, this privateness is easily circum- vented as follows: Employee joe; (joe.getSalary( )).input( ); The lucky employee named joe can now enter any salary she wishes! On the other hand, suppose getSalary returns its value by const value, as follows: class Employee { public: const Money getSalary( ) { return salary; } . . . private: Money salary; . . . }; In this case, the following will give a compiler error message. (joe.getSalary( )).input( ); (The declaration for getSalary should ideally be const Money getSalary( ) const { return salary; } but we did not want to confuse the issue with another kind of const.) 08_CH08.fm Page 312 Wednesday, August 13, 2003 1:02 PM Basic Operator Overloading 313 Self-Test Exercises 4. Suppose you omit the const at the beginning of the declaration and definition of the over- loaded plus operator for the class Money, so that the value is not returned by const value. Is the following legal? Money m1(10.99), m2(23.57), m3(12.34); (m1 + m2) = m3; Is it legal if the definition of the class Money is as shown in Display 8.1, so that the plus operator returns its value by const value? ■ OVERLOADING UNARY OPERATORS In addition to the binary operators, such as + in x + y, C++ has unary operators, such as the operator - when it is used to mean negation. A unary operator is an operator that takes only one operand (one argument). In the statement below, the unary opera- tor - is used to set the value of a variable x equal to the negative of the value of the vari- able y: x = -y; The increment and decrement operators, ++ and , are other examples of unary oper- ators. You can overload unary operators as well as binary operators. For example, we have overloaded the minus operator - for the type Money (Display 8.1) so that it has both a unary and a binary operator version of the subtraction/negation operator For exam- ple, suppose your program contains this class definition and the following code: Money amount1(10), amount2(6), amount3; Then the following sets the value of amount3 to amount1 minus amount2: amount3 = amount1 - amount2; The following will, then, output $4.00 to the screen: amount3.output( ); On the other hand, the following will set amount3 equal to the negative of amount1: amount3 = -amount1; The following will, then, output -$10.00 to the screen: amount3.output( ); unary operator 08_CH08.fm Page 313 Wednesday, August 13, 2003 1:02 PM . dollarsPart(amountAsDouble); 153 cents = centsPart(amountAsDouble); 154 } 155 int Money::dollarsPart(double amount) const 156 < The rest of the definition is the same as BankAccount::dollarsPart. return- Display 8.1 Operator Overloading (part 5 of 5) 157 int Money::centsPart(double amount) const 158 < The rest of the definition is the same as BankAccount::centsPart in Display 7.2. > 159 int. //negative cents. Negative $4.50 is represented as -4 and -50. 21 int dollarsPart(double amount) const; 22 int centsPart(double amount) const; 23 int round(double number) const; 24 }; 25 const