Skip to main content

Engineering Computer Science C++ How to Program (10th Edition)

To enhance the DollarAmounts class from exercise 10.12E to make overloaded operators commutative. To add two instances of class and storing the value in another instance will behave as commutative with our current implementation. DollarAmount da1, da2, da3; da3 = da1 + da2 is similar to da3 = da2 + da1 However, when we add an 64int_t to an instance of DollarAmount, the following operations are numerically legal but fail to match the operator+ argument list: int64_t data; da3 = da1 + data; To support above statement, we have to overloaded + operator as class’s member function, with int64_t as argument but following statement will fail at compilation time as operator + will not be invoked by primitive data type int64_t da3 = data + da1 To support this, we will add a global method to class to act as overloaded operator, and to grant access to private members of class, we will make it friend function. Modified Program: #include<string> #include<cmath> #include<iostream> usingnamespace std; classDollarAmount { public: // initialize amount from an int64_t value explicitDollarAmount(int64_t value) : amount(value) { dollars = (amount / 100); cents = std::abs(amount % 100); } DollarAmount(int64_t dol, int64_t cnt) : dollars(dol), cents(cnt) { amount = calculate(dol, cnt); } //calculate amount from dollars and cents int64_t calculate(int64_t dol, int64_t cnt) { int64_t pennies = (dol * 100) + cnt; return pennies; } //define friend function to support commutativity of operators overloaded friendconstDollarAmountoperator+(const int64_t x, constDollarAmount& Q){ DollarAmount result(Q.amount); result.amount = x + Q.amount; return result; } friendconstDollarAmountoperator*(const int64_t x, constDollarAmount& Q){ DollarAmount result(Q.amount); result.amount = x * Q.amount; return result; } // add right's amount to this object's amount void add(DollarAmount right) { // can access private data of other objects of the same class amount += right.amount; } // subtract right's amount from this object's amount void subtract(DollarAmount right) { // can access private data of other objects of the same class amount -= right.amount; } // uses integer arithmetic to calculate interest amount, // then calls add with the interest amount voidaddInterest(int rate, int divisor) { // create DollarAmount representing the interest DollarAmount interest { (amount * rate + divisor / 2) / divisor }; cout<<"Creating Interest Object :"<<interest.toString()<<endl; add(interest); // add interest to this object's amount } // return a string representation of a DollarAmount object std::stringtoString() const { std::string dollars { std::to_string(amount / 100) }; std::string cents { std::to_string(std::abs(amount % 100)) }; return dollars + "." + (cents.size() == 1 ? "0" : "") + cents; } //Overloaded + operator DollarAmount&operator +(DollarAmount&tmp){ DollarAmountddd{*this}; amount += tmp.amount; return *this; } // to support scalar addition DollarAmount&operator+(int64_t i){ DollarAmountddd{*this}; amount += i; return *this; } //Overloaded - operator DollarAmount&operator -(DollarAmount&tmp){ DollarAmountddd{*this}; amount -= tmp.amount; return *this; } //Overloaded * operator DollarAmount&operator *(DollarAmount&tmp){ DollarAmountddd{*this}; amount *= tmp.amount; return *this; } // to support scalar multiplication DollarAmount&operator*(int64_t i){ DollarAmountddd{*this}; amount *= i; return *this; } //Overloaded / operator DollarAmount&operator /(DollarAmount&tmp){ DollarAmountddd{*this}; amount /= tmp.amount; return *this; } private: int64_t amount { 0 }; // dollar amount in pennies int64_t cents; // cents int64_t dollars; //dollars in whole numbers }; intmain(void){ DollarAmount da1 (345,29); DollarAmount da2 (29875); DollarAmount da3 (0); DollarAmount da4 (0); cout<<"Creating objects of DollarAmounts"<<endl <<"First :" <<da1.toString()<<endl <<"Second :"<<da2.toString() <<endl <<"Third :" <<da3.toString()<<endl <<"Fourth :"<<da4.toString() <<endl; cout<<"Beginning tests using overloaded operators"<<endl <<" da1 = da1 + da2"<<endl; da1 = da1 + da2; //add two dollar amounts da2 = da1 + da2; //add two dollar amounts cout<<" DollarAmount da1 after adding da2 using + operator :"<<endl <<da1.toString() <<endl; cout<<" DollarAmount da1 after adding da2 using + operator :"<<endl <<da2.toString() <<endl; } Sample Output: Creating objects of DollarAmounts First :345.29 Second :298.75 Third :0.00 Fourth :0.00 Beginning tests using overloaded operators da1 = da1 + da2 DollarAmount da1 after adding da2 using + operator : 942.79 DollarAmount da1 after adding da2 using + operator : 942.79

To enhance the DollarAmounts class from exercise 10.12E to make overloaded operators commutative. To add two instances of class and storing the value in another instance will behave as commutative with our current implementation. DollarAmount da1, da2, da3; da3 = da1 + da2 is similar to da3 = da2 + da1 However, when we add an 64int_t to an instance of DollarAmount, the following operations are numerically legal but fail to match the operator+ argument list: int64_t data; da3 = da1 + data; To support above statement, we have to overloaded + operator as class’s member function, with int64_t as argument but following statement will fail at compilation time as operator + will not be invoked by primitive data type int64_t da3 = data + da1 To support this, we will add a global method to class to act as overloaded operator, and to grant access to private members of class, we will make it friend function. Modified Program: #include<string> #include<cmath> #include<iostream> usingnamespace std; classDollarAmount { public: // initialize amount from an int64_t value explicitDollarAmount(int64_t value) : amount(value) { dollars = (amount / 100); cents = std::abs(amount % 100); } DollarAmount(int64_t dol, int64_t cnt) : dollars(dol), cents(cnt) { amount = calculate(dol, cnt); } //calculate amount from dollars and cents int64_t calculate(int64_t dol, int64_t cnt) { int64_t pennies = (dol * 100) + cnt; return pennies; } //define friend function to support commutativity of operators overloaded friendconstDollarAmountoperator+(const int64_t x, constDollarAmount& Q){ DollarAmount result(Q.amount); result.amount = x + Q.amount; return result; } friendconstDollarAmountoperator(const int64_t x, constDollarAmount& Q){ DollarAmount result(Q.amount); result.amount = x Q.amount; return result; } // add right's amount to this object's amount void add(DollarAmount right) { // can access private data of other objects of the same class amount += right.amount; } // subtract right's amount from this object's amount void subtract(DollarAmount right) { // can access private data of other objects of the same class amount -= right.amount; } // uses integer arithmetic to calculate interest amount, // then calls add with the interest amount voidaddInterest(int rate, int divisor) { // create DollarAmount representing the interest DollarAmount interest { (amount * rate + divisor / 2) / divisor }; cout<<"Creating Interest Object :"<<interest.toString()<<endl; add(interest); // add interest to this object's amount } // return a string representation of a DollarAmount object std::stringtoString() const { std::string dollars { std::to_string(amount / 100) }; std::string cents { std::to_string(std::abs(amount % 100)) }; return dollars + "." + (cents.size() == 1 ? "0" : "") + cents; } //Overloaded + operator DollarAmount&operator +(DollarAmount&tmp){ DollarAmountddd{this}; amount += tmp.amount; return this; } // to support scalar addition DollarAmount&operator+(int64_t i){ DollarAmountddd{this}; amount += i; return this; } //Overloaded - operator DollarAmount&operator -(DollarAmount&tmp){ DollarAmountddd{this}; amount -= tmp.amount; return this; } //Overloaded * operator DollarAmount&operator (DollarAmount&tmp){ DollarAmountddd{this}; amount = tmp.amount; return this; } // to support scalar multiplication DollarAmount&operator(int64_t i){ DollarAmountddd{this}; amount = i; return this; } //Overloaded / operator DollarAmount&operator /(DollarAmount&tmp){ DollarAmountddd{this}; amount /= tmp.amount; return this; } private: int64_t amount { 0 }; // dollar amount in pennies int64_t cents; // cents int64_t dollars; //dollars in whole numbers }; intmain(void){ DollarAmount da1 (345,29); DollarAmount da2 (29875); DollarAmount da3 (0); DollarAmount da4 (0); cout<<"Creating objects of DollarAmounts"<<endl <<"First :" <<da1.toString()<<endl <<"Second :"<<da2.toString() <<endl <<"Third :" <<da3.toString()<<endl <<"Fourth :"<<da4.toString() <<endl; cout<<"Beginning tests using overloaded operators"<<endl <<" da1 = da1 + da2"<<endl; da1 = da1 + da2; //add two dollar amounts da2 = da1 + da2; //add two dollar amounts cout<<" DollarAmount da1 after adding da2 using + operator :"<<endl <<da1.toString() <<endl; cout<<" DollarAmount da1 after adding da2 using + operator :"<<endl <<da2.toString() <<endl; } Sample Output: Creating objects of DollarAmounts First :345.29 Second :298.75 Third :0.00 Fourth :0.00 Beginning tests using overloaded operators da1 = da1 + da2 DollarAmount da1 after adding da2 using + operator : 942.79 DollarAmount da1 after adding da2 using + operator : 942.79

Solution Summary: The author explains how to enhance the DollarAmounts class from exercise 10.12E to make overloaded operators commutative.

C++ How to Program (10th Edition)

C++ How to Program (10th Edition)

10th Edition

ISBN: 9780134448237

Author: Paul J. Deitel, Harvey Deitel

Publisher: PEARSON

See similar textbooks

Expert Solution & Answer

Want to see the full answer?

Check out a sample textbook solution

Blurred answer

Chapter 10, Problem 10.12E

Chapter 11, Problem 11.3E

Students have asked these similar questions

(Java in eclipse).

“Type casting is essential when we use function malloc().”-Explain it withsuitable example.

Question 4: (30 marks) A Math teacher is teaching Math course to a set of classes (each class may have different number of students) and want to check the behavior of his students in a homework report. The teacher gave the classes the same exam and marked their answer and wants to know the class whose students got the highest average. Help the teacher in the required analysis of student’s marks by implementing a Java program ClassAverageMArks2DimmArray using 2-dimensional array to store the students marks and then compute the average of each class student’s marks. The program has the following specification: • A Method titled averageClassMarks for computing the average (as double) of a class students marks (given to the method as a single-dimensional array) • Another Method titled averageAllClassesMarks for computing the average (as single array of double) of all the classes class student’s marks (given to the method as a 2dimensional array). This method has to repeatedly call the…

Chapter 10 Solutions

C++ How to Program (10th Edition)

Ch. 10 - Prob. 10.6E Ch. 10 - ( Overloading the Parentheses Operator) One nice...Ch. 10 - (Complex Class) Consider class Complex shown in...Ch. 10 - ( HugeInteger Class) A machine with 32- bit...Ch. 10 - (Rational Number Class) Create a rational Number...Ch. 10 - (Polynomial Class) Develop class polynomial. The...Ch. 10 - Prob. 10.12E Ch. 10 - Prob. 10.13E

Knowledge Booster

Background pattern image

Similar questions

SEE MORE QUESTIONS

Recommended textbooks for you

C++ Programming: From Problem Analysis to Program...
Computer Science
ISBN:9781337102087
Author:D. S. Malik
Publisher:Cengage Learning

Text book image

C++ Programming: From Problem Analysis to Program...

Computer Science

ISBN:9781337102087

Author:D. S. Malik

Publisher:Cengage Learning

SEE MORE TEXTBOOKS