Answers for chapter 14
Exercise 14.1: In what ways does an overloaded operator differ from a built-in operator? In what ways are overloaded operators the same as the built-in operators?
Exercise 14.2: Write declarations for the overloaded input, output, addition, and compound-assignment operators for Sales_data.
Exercise 14.3: Both string and vector define an overloaded == that can be used to compare objects of those types. Assuming svec1 and svec2 are vectors that hold strings, identify which version of == is applied in each of the following expressions:
(a) "cobble" == "stone" //comparing two pointers
(b) svec1[0] == svec2[0] //string version
(c) svec1 == svec2 //vector version
(d) "svec1[0] == "stone" //string version
Exercise 14.4: Explain how to decide whether the following should be class members:
(a) % non-member, Symmetric operators
(b) %= member, compound-assignment operators
(c) ++ //member, Operators that change the state of their object or that are closely tied to their given type
(d) -> //must be member
(e) << //non-member
(f) && //Shouldn’t Be Overloaded, the operator has order of evaluation and short-cut property
(g) == non-member, Symmetric operators
(h) () //must be member
Exercise 14.5: In exercise 7.40 from § 7.5.1 (p. 291) you wrote a sketch of one of the following classes. Decide what, if any, overloaded operators your class should provide.
(a) Book
//arithmatic: +, +=
//equality: ==, !=
//stream: << >>
Exercise 14.6: Define an output operator for your Sales_data class.
Please see Exercise 14.2
Exercise 14.7: Define an output operator for you String class you wrote for the exercises in § 13.5 (p. 531).
Please see Exercise 13.44
Exercise 14.8: Define an output operator for the class you chose in exercise 7.40 from § 7.5.1 (p. 291).
Exercise 14.10: Describe the behavior of the Sales_data input operator if given the following input:
(a) 0-201-99999-9 10 24.95
(b) 10 24.95 0-210-99999-9
The first input yields the correct answer. The second input doesn't.
//output
0-201-99999-9 10 249.5 24.95
10 24 22.8 0.95
Exercise 14.11: What, if anything, is wrong with the following Sales_data input operator? What would happen if we gave this operator the data in the previous exercise?
istream& operator>>(istream& in, Sales_data& s)
{
double price;
in >> s.bookNo >> s.units_sold >> price;
s.revenue = s.units_sold * price;
return in;
}
This program failed to validate whether the input was in the proper state. The second input won't be correct based on the given inputs.
Exercise 14.12: Define an input operator for the class you used in exercise 7.40 from § 7.5.1 (p. 291). Be sure the operator handles input errors.
Exercise 14.13: Which other arithmetic operators (Table 4.1 (p. 139)), if any, do you think Sales_data ought to support? Define any you think the class should include.
Currently, the Sales_data class has been overloaded +
, +=
operators. In my opinion it is good enough.
Exercise 14.14: Why do you think it is more efficient to define operator+ to call operator+= rather than the other way around?
+
through the +=
:+=
takes a reference, and returns a reference, thus there is no copy happening.+
returns the result. (1 copy)+=
through the +
:+
needs to create a local object to store the result. (1 copy)+
have to return the temporary result to +=
by value (2 copies)
In sum, implementing the +
based on the +=
is more effective.
Exercise 14.15: Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291) define any of the arithmetic operators? If so, implement them. If not, explain why not.
There should be an +
and a +=
to combine the revenue of two books, as well as an equality operator to check if two books have the same ISBN.
CODE : header
source test file
Exercise 14.16: Define equality and inequality operators for your StrBlob (§ 12.1.1, p. 456), StrBlobPtr (§ 12.1.6, p. 474), StrVec (§ 13.5, p. 526), and String (§ 13.5, p. 531) classes.
StrBlob & StrBlobPtr : header
source test file
StrVec: header
source test file
String: header
source test file
Exercise 14.17: Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291) define the equality operators? If so, implement them. If not, explain why not.
Please see Exercise 14.15
Exercise 14.18: Define relational operators for your StrBlob, StrBlobPtr, StrVec, and String classes.
StrBlob & StrBlobPtr : header
source test file
StrVec: header
source test file
String: header
source test file
Exercise 14.19: Should the class you chose for exercise 7.40 from § 7.5.1 (p. 291) define the relational operators? If so, implement them. If not, explain why not.
Exercise 14.20: Define the addition and compound-assignment operators for your Sales_data class.
Exercise 14.21: Write the Sales_data operators so that + does the actual addition and += calls +. Discuss the disadvantages of this approach compared to the way these operators were defined in § 14.3 (p. 560) and § 14.4 (p. 564).
As we discussed in exercise 14.14 before, using +
in order to implement +=
will spend extra but redundant copies on temporaries and returns.
CODE : header
source test file
Exercise 14.22: Define a version of the assignment operator that can assign a string representing an ISBN to a Sales_data.
Exercise 14.23: Define an initializer_list assignment operator for your version of the StrVec class.
Exercise 14.24: Decide whether the class you used in exercise 7.40 from § 7.5.1 (p. 291) needs a copy- and move-assignment operator. If so, define those operators.
No. The the synthesized version works well for the Book class.
Exercise 14.25: Implement any other assignment operators your class should define. Explain which types should be used as operands and why.
No other assignment operator needed for Books class.
Exercise 14.26: Define subscript operators for your StrVec, String, StrBlob, and StrBlobPtr classes.
StrBlob & StrBlobPtr : header
source test file
StrVec: header
source test file
String: header
source test file
Exercise 14.27: Add increment and decrement operators to your StrBlobPtr class.
Exercise 14.28: Define addition and subtraction for StrBlobPtr so that these operators implement pointer arithmetic (§ 3.5.3, p. 119).
Exercise 14.29: We did not define a const version of the increment and decrement operators. Why not?
Incerment & Decrement changes the state of the object itself, thus they must be non-const function.
Exercise 14.30: Add dereference and arrow operators to your StrBlobPtr class and to the ConstStrBlobPtr class that you defined in exercise 12.22 from § 12.1.6 (p. 476). Note that the operators in constStrBlobPtr must return const references because the data member in constStrBlobPtr points to a const vector.
Exercise 14.31: Our StrBlobPtr class does not define the copy constructor, assignment operator, or a destructor. Why is that okay?
Because there is only one data member, weak_ptr, and there is no dynamic allocation involved. The synthesized one will handle it well.
Exercise 14.32: Define a class that holds a pointer to a StrBlobPtr. Define the overloaded arrow operator for that class.
CODE : Q.1
Exercise 14.33: How many operands may an overloaded function-call operator take?
256.
C++ Language, Annex B - Implementation quantities: … — Parameters in one function definition [256].
Exercise 14.34: Define a function-object class to perform an if-then-else operation: The call operator for this class should take three parameters. It should test its first parameter and if that test succeeds, it should return its second parameter; otherwise, it should return its third parameter.
Exercise 14.35: Write a class like PrintString that reads a line of input from an istream and returns a string representing what was read. If the read fails, return the empty string.
Exercise 14.36: Use the class from the previous exercise to read the standard input, storing each line as an element in a vector.
Exercise 14.37: Write a class that tests whether two values are equal. Use that object and the library algorithms to write a program to replace all instances of a given value in a sequence.
Exercise 14.38: Write a class that tests whether the length of a given string matches a given bound. Use that object to write a program to report how many words in an input file are of sizes 1 through 10 inclusive.
Exercise 14.39: Revise the previous program to report the count of words that are sizes 1 through 9 and 10 or more.
Exercise 14.40: Rewrite the biggies function from § 10.3.2 (p. 391) to use function-object classes in place of lambdas.
Exercise 14.41: Why do you suppose the new standard added lambdas? Explain when you would use a lambda and when you would write a class instead.
Lambda is more terse than a function object. However, in some cases, we might be able to benefit from using function objects, as the function may be reused. For instance, finding the biggest number. We know various numbers may be present. In this case, if we use lambdas, we end up with duplicated codes, whereas we could implement another function call overloading with a different number of parameters to handle the case.
As a result, lambda should be used for simple or temporary applications. When the case becomes more complex, consider using a function object.
Exercise 14.42: Using library function objects and adaptors, define an expression to
CODE : Q.1
Exercise 14.43: Using library function objects, determine whether a given int value is divisible by any element in a container of ints.
CODE : Q.1
Exercise 14.44: Write your own version of a simple desk calculator that can handle binary operations.
CODE : Q.1
Exercise 14.45: Write conversion operators to convert a Sales_data to string and to double. What values do you think these operators should return?
book_no
avg_price()
Exercise 14.46: Explain whether defining these Sales_data conversion operators is a good idea and whether they should be explicit.
For Sales_data class, it is not a good idea to overload the conversion operators. Conversion operators should be defined only if there is an obvious single mapping between the class type and the conversion type.
Exercise 14.47: Explain the difference between these two conversion operators:
struct Integral {
operator const int(); // conversion operator that convert the integral class type to const int type. The member should be a const member
operator int() const; // conversion operator that convert the integral class type to int type
};
Exercise 14.48: Determine whether the class you used in exercise 7.40 from § 7.5.1 (p. 291) should have a conversion to bool. If so, explain why, and explain whether the operator should be explicit. If not, explain why not.
No. In general, there is no obvious mapping between the Book
class type and any other conversion type.
Exercise 14.49: Regardless of whether it is a good idea to do so, define a conversion to bool for the class from the previous exercise.
Exercise 14.50: Show the possible class-type conversion sequences for the initializations of ex1 and ex2. Explain whether the initializations are legal or not.
struct LongDouble {
LongDouble(double = 0.0);
operator double();
operator float();
};
LongDouble ldObj;
int ex1 = ldObj;
float ex2 = ldObj;
ex1
is illegal. In order to initialize ex1
, the object ldObj
of class-type LongDouble need to be converted to int
first; however, both custom conversions in LongDouble class-type are equally good for the conversion, which results in an ambiguous result.ex2
is good, the float version has the higher rank of conversion. It will convert LongDouble to float to satisfy the assignment's requirement.Exercise 14.51: Show the conversion sequences (if any) needed to call each version of calc and explain why the best viable function is selected.
void calc(int);
void calc(LongDouble);
double dval;
calc(dval); // which calc?
In this case, the LongDouble version will convert built-in type double
to the longDouble class-type first. The conversion between an arithmetic type and a class-type has the lowest ranking in the best-match process. By contrast, the int
version only requires arithmetic conversion, making it higher ranked. Thus, void calc(int)
is the best viable function.
Exercise 14.52: Which operator+, if any, is selected for each of the addition expressions? List the candidate functions, the viable functions, and the type conversions on the arguments for each viable function:
struct LongDouble {
// member operator+ for illustration purposes; + is usually a nonmember
LongDouble operator+(const SmallInt&);
// other members as in § 14.9.2 (p. 587)
};
LongDouble operator+(LongDouble&, double);
SmallInt si;
LongDouble ld;
ld = si + ld;
ld = ld + si;
ld = si + ld;
+
functions (members, non-members, built-in)SmallInt
and LongDouble
cannot be converted one to another, none of the versions that take an parameter of type SmallInt
or LongDouble
can be used for the operation.SmallInt
will be converted to int
, LongDouble
can be converted to both float
and double
, Thus both operator+(int, float)
and operator+(int, double)
are equally good.ld = ld + si
+
functions (members, non-members, built-in)LongDouble
member operator +
and bulit-in membersLongDouble
member operator +
. The operation is equal to ld.operator+(si)
.Exercise 14.53: Given the definition of SmallInt on page 588, determine whether the following addition expression is legal. If so, what addition operator is used? If not, how might you change the code to make it legal?
SmallInt s1;
double d = s1 + 3.14;
The function call is an ambiguous call. s1 + 3.14
can call either non-member operator+(const SmallInt&, const SmallInt&)
, or built-in operation operator+(int, int)
, because SmallInt
object can be converted into int
through the conversion operator, and int
can be converted into SmallInt
type as well through the conversion constructor. double d = s1 + SmartInt(3.14);