Thinking in C++ Vol 2 - Practical Programming |
Prev |
Home |
Next |
Solutions
to selected exercises can be found in the electronic document The Thinking
in C++ Volume 2 Annotated Solution Guide, available for a small fee from www.MindView.net.
1. Write three functions: one
that returns an error value to indicate an error condition, one that sets errno,
and one that uses signal( ). Write code that calls these functions
and responds to the errors. Now write a fourth function that throws an
exception. Call this function and catch the exception. Describe the differences
between these four approaches, and why exception handling is an improvement.
2. Create a class with member functions that throw exceptions.
Within this class, make a nested class to use as an exception object. It takes
a single const char* as its argument; this represents a description
string. Create a member function that throws this exception. (State this in the
function s exception specification.) Write a try block that calls this
function and a catch clause that handles the exception by displaying its
description string.
3. Rewrite the Stash class from Chapter 13 of Volume 1 so
that it throws out_of_range exceptions for operator[ ].
4. Write a generic main( ) that takes all exceptions and
reports them as errors.
5. Create a class with its own operator new. This operator
should allocate ten objects, and on the eleventh object run out of memory and
throw an exception. Also add a static member function that reclaims this
memory. Now create a main( ) with a try block and a catch
clause that calls the memory-restoration routine. Put these inside a while
loop, to demonstrate recovering from an exception and continuing execution.
6. Create a destructor that throws an exception, and write code to
prove to yourself that this is a bad idea by showing that if a new exception is
thrown before the handler for the existing one is reached, terminate( )
is called.
7. Prove to yourself that all exception objects (the ones that are
thrown) are properly destroyed.
8. Prove to yourself that if you create an exception object on the
heap and throw the pointer to that object, it will not be cleaned up.
9. Write a function with an exception specification that can throw
four exception types: a char, an int, a bool, and your own
exception class. Catch each in main( ) and verify the catch. Derive
your exception class from a standard exception. Write the function in such a
way that the system recovers and tries to execute it again.
10. Modify your solution to the previous exercise to throw a double
from the function, violating the exception specification. Catch the violation
with your own unexpected handler that displays a message and exits the program
gracefully (meaning abort( ) is not called).
11. Write a Garage class that has a Car that is having
troubles with its Motor. Use a function-level try block in the Garage
class constructor to catch an exception (thrown from the Motor class)
when its Car object is initialized. Throw a different exception from the
body of the Garage constructor s handler and catch it in main( ).