Question

Following is the definition for a class called Percent. Objects of type Percent represent percentages such as 10% or 99%. Give the definitions of the overloaded operators >> and << so that they can be used for input and output with objects of the class Percent. Assume that input always consists of an integer followed by the character ‘%’, such as 25%. All per- centages are whole numbers and are stored in the int member variable named value. You do not need to define the other overloaded operators and do not need to define the constructor. You only have to define the overloaded operators >> and <<. #include using namespace std; class Percent { public: friend bool operator ==(const Percent& first, const Percent& second); friend bool operator <(const Percent& first, const Percent& second); Percent( ); Percent(int percent_value ); friend istream& operator >>(istream& ins, Percent& the_object); //Overloads the >> operator to input values of type //Percent. //Precondition: If ins is a file input stream, then ins //has already been connected to a file. friend ostream& operator <<(ostream& outs, const Percent& a_percent); //Overloads the << operator for output values of type //Percent. //Precondition: If outs is a file output stream, then //outs has already been connected to a file. private: int value; };

Short answer

Answer: To implement the input >> operator for the Percent class, we extract the percentage value as an integer from the input stream, read the '%' character, and store the extracted value into the 'value' member variable of the Percent object. For the output << operator, we simply output the value stored in the 'value' member variable of the Percent object, followed by the '%' character.

Step-by-step solution

Define the >> Operator

In order to overload the >> operator, we will use the 'istream& operator >>' declaration provided within the class. We will start by extracting the percentage value as an integer from the input stream, and then reading the '%' character. After that, we will store the extracted value into the 'value' member variable of the_object (the instance of the Percent class). Here is the implementation: istream& operator >>(istream& ins, Percent& the_object) { int temp_value; char percent_sign; ins >> temp_value; ins >> percent_sign; if (percent_sign == '%') { the_object.value = temp_value; } return ins; }

Define the

Now, we will overload the << operator, again using the provided 'ostream& operator <<' declaration from the class. In this case, we just need to output the value stored in the 'value' member variable of a_percent (the instance of the Percent class), followed by the '%' character. Here is the implementation: ostream& operator <<(ostream& outs, const Percent& a_percent) { outs << a_percent.value << '%'; return outs; }

Key concepts

C++ Class Design

When designing a class in C++, structuring it effectively is critical. Classes serve as blueprints for objects and encapsulate related data and functions. The Percent class in this exercise is a prime example of focused class design, where it represents a concept of percentage. It holds an integral value that denotes the percentage.

The class design incorporates both the internal state (value) and the interface with which users interact (overloaded operators and constructors). A key aspect of an effective class design is considering the scope of member variables and functions. The value is kept private to preserve encapsulation, which means it can only be manipulated through class methods or friend functions.

Overloading operators in class design improves object interactivity in a way that is natural for the language. For instance, here the operator>> and operator<< are overloaded to allow direct I/O operations on the Percent objects, mimicking the built-in types for a seamless experience.

istream and ostream

The istream and ostream classes in C++ handle input and output, respectively. They are part of the standard library's I/O stream hierarchy, and they provide a foundation for performing I/O operations on various data types.

Overloading the operator>> for istream allows custom objects to be read directly from input streams such as cin or a file stream. For the Percent class, the overload extracts an integer followed by a '%' character, integrates these inputs into the internal state of a Percent object, and maintains the stream's integrity.

Similarly, overloading the operator<< for ostream enables objects to be outputted through streams like cout or a file stream. The implementation ensures that a Percent object is expressed as a combination of its integral value followed by the '%' sign, formatted correctly for display or storage.

Both overloads return their respective stream references, which supports chaining of I/O operations, a common practice in C++ programming.

Friend Functions in C++

Friend functions provide a way to extend the interface of a class without being members of the class itself. In the context of the Percent class, friend functions are used to overload operators. Since the operator>> and operator<< need to access private member data, they require special access.

By declaring these functions as friends inside the class definition, we grant them the capability to interact with private and protected members just like any other member function. However, they remain non-member functions and thus do not affect the size of the class or its instantiation.

Friend functions are particularly useful in operator overloading when the operator needs to access internal data from multiple objects or when working with I/O streams where the left-hand operand must be a stream object that the class does not control. The use of friend functions ensures those operators have the necessary access without compromising the encapsulation principles that are central to object-oriented design.