Question

Suppose you wish to add a friend function for subtraction to the class Money defined in Display \(11.3 .\) What do you need to add to the description of the class Money that we gave in Display \(11.3 ?\) The subtraction function should take two arguments of type Money and return a value of type Money whose value is the value of the first argument minus the value of the second argument.

Short answer

Answer: To subtract two Money objects using a friend function, you need to first declare the friend function inside the Money class: ```cpp friend Money operator-(const Money& amount1, const Money& amount2); ``` Then, define the friend function outside the Money class: ```cpp Money operator-(const Money& amount1, const Money& amount2) { int all_cents1 = amount1.cents + amount1.dollars*100; int all_cents2 = amount2.cents + amount2.dollars*100; int diff_all_cents = all_cents1 - all_cents2; int final_dollars = diff_all_cents / 100; int final_cents = diff_all_cents % 100; return Money(final_dollars, final_cents); } ``` Now, you can use the '- (minus)' operator to subtract two Money objects, and the friend function will be called, returning the result as a new Money object.

Step-by-step solution

Analyzing the class Money in Display 11.3

First, let's analyze the Money class, which is described in Display 11.3. The class contains a constructor, an output method, and several other functions. We will need to add a friend function for subtraction to this class.

Declare the friend function for subtraction within the class Money

Inside the class Money, declare the friend function with the following line: ``` friend Money operator-(const Money& amount1, const Money& amount2); ``` This declares a function named "operator-" that takes two Money objects as constant references and returns a Money object.

Define the friend function for subtraction outside the class Money

After the closing brace of the Money class, define the friend function for subtraction as follows: ``` Money operator-(const Money& amount1, const Money& amount2) { int all_cents1 = amount1.cents + amount1.dollars*100; int all_cents2 = amount2.cents + amount2.dollars*100; int diff_all_cents = all_cents1 - all_cents2; int final_dollars = diff_all_cents / 100; int final_cents = diff_all_cents % 100; return Money(final_dollars, final_cents); } ``` This function calculates the total cents for both given Money objects (amount1 and amount2) and then subtracts the total cents of amount2 from the total cents of amount1. The result is converted back into dollars and cents, and a new Money object is created and returned with the resulting values. Now the class Money will have a friend function for subtraction as defined above, and it should work correctly for subtracting two Money objects.

Key concepts

Friend Functions

In C++ programming, friend functions are a powerful feature that allows external functions to access the private and protected members of a class. These functions are especially useful when two or more classes need to work closely together.
This means they can bypass the usual encapsulation controls of object-oriented programming.
The concept of a friend function becomes crucial when you want to perform an operation that involves more than one object of the same class or different classes. When you declare a function as a friend in a class, it allows that particular function to have unrestricted access to all the member variables and functions within that class.

• Declared using the keyword `friend` within a class.
• Not a member of the class, but still has access to its private and protected members.
• Usually defined outside the class scope.

For example, in a "Money" class, a friend function can be used for operations like subtraction, where you allow the function to directly access dollars and cents member variables to compute the result.

Operator Overloading

Operator overloading in C++ allows developers to redefine the behavior of operators to work with user-defined data types like classes. This feature enhances the readability and maintainability of the code by allowing developers to use operators with custom objects, similar to built-in types.
When overloading operators, you define how an operator works with objects of a particular class. For instance, the minus `-` operator can be overloaded to allow subtraction between two "Money" objects. This involves defining a new behavior for the operator to handle these objects meaningfully.

• Operators are overloaded by defining a function using the `operator` keyword followed by the symbol.
• The function can be a member function or a friend function.
• Returns the result of the operation as an object of the user-defined type.

In this case, for a "Money" class, we use a friend function to overload the `-` operator. This function takes two "Money" objects as arguments and returns a new "Money" object that represents the difference between the two. This way, we can intuitively use `-` between two instances of "Money".

Class Definition

At the core of C++ object-oriented programming lies the class definition, where you define the structure and behavior of objects. Classes encapsulate data for the object and methods to operate on that data, enabling modular and reusable code. In the context of a "Money" class, the definition would include the declaration of attributes to store values like dollars and cents. Class definitions begin with the `class` keyword, followed by the class name, and then a block containing data members and member functions.
A class definition involves:

• Private data members to hold the state of an object.
• Public member functions for object state manipulation and interaction.
• Constructors and destructors to manage resources.
• Optionally, friend functions, especially for operations involving multiple instances like subtraction.

By understanding class definition, you can craft classes that not only encapsulate and manage complex data but also define intricate behaviors and interactions among objects.

Object-Oriented Programming

Object-Oriented Programming (OOP) is a paradigm based on the concept of objects, which can contain data, in the form of fields, and code, in the form of procedures. C++ leverages OOP extensively and allows developers to create classes that model real-world entities closely. This makes programs more flexible and easier to maintain. Key concepts of OOP in C++ include:

• Encapsulation: Bundling data and methods that operate on the data within classes.
• Abstraction: Hiding complex implementation details and exposing only necessary parts through interfaces.
• Inheritance: Creating new classes based on existing ones to promote code reuse.
• Polymorphism: Allowing methods to do different things based on the object it is acting upon.

In our "Money" example, we see encapsulation through private members, abstraction with public methods, and using friend functions like operator overloading to elegantly manage interactions between two objects. Together, these principles make your code structured, efficient, and intuitive. OOP in C++ facilitates creating systems that are more aligned with real-world processes, enhancing both the development and usability of software.