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

Describe three (3) Multiplexing techniques common for fiber optic links

Could you help me to know features of the following concepts: - commercial CA - memory integrity - WMI filter

Briefly describe the issues involved in using ATM technology in Local Area Networks

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
C++ for Engineers and Scientists
Computer Science
ISBN:9781133187844
Author:Bronson, Gary J.
Publisher:Course Technology Ptr
Microsoft Visual C#
Computer Science
ISBN:9781337102100
Author:Joyce, Farrell.
Publisher:Cengage Learning,

Text book image

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

Computer Science

ISBN:9781337102087

Author:D. S. Malik

Publisher:Cengage Learning

Text book image

C++ for Engineers and Scientists

Computer Science

ISBN:9781133187844

Author:Bronson, Gary J.

Publisher:Course Technology Ptr

Text book image

Microsoft Visual C#

Computer Science

ISBN:9781337102100

Author:Joyce, Farrell.

Publisher:Cengage Learning,

SEE MORE TEXTBOOKS