16 Exception Handling

1. 16.1 Exception-Handling Basics 897

   1. A Toy Example of Exception Handling 897

   2. Defining Your Own Exception Classes 906

   3. Multiple Throws and Catches 906

   4. Pitfall: Catch the More Specific Exception First 910

   5. Programming Tip: Exception Classes Can Be Trivial 911

   6. Throwing an Exception in a Function 911

   7. Exception Specification 913

   8. Pitfall: Exception Specification in Derived Classes 915

2. 16.2 Programming Techniques For Exception Handling 916

   1. When to Throw an Exception 916

   2. Pitfall: Uncaught Exceptions 918

   3. Pitfall: Nested try-catch Blocks 918

   4. Pitfall: Overuse of Exceptions 918

   5. Exception Class Hierarchies 919

   6. Testing for Available Memory 919

   7. Rethrowing an Exception 920

1. Chapter Summary 920

2. Answers to Self-Test Exercises 920

3. Practice Programs 922

4. Programming Projects 923

It’s the exception that proves the rule.

COMMON MAXIM (possibly a corruption of something like: It’s the exception that tests the rule.)

Introduction

One way to write a program is to first assume that nothing unusual or incorrect will happen. For example, if the program takes an entry off a list, you might assume that the list is not empty. Once you have the program working for the core situation where things always go as planned, you can then add code to take care of the exceptional cases. In C++, there is a way to reflect this approach in your code. Basically, you write your code as if nothing very unusual happens. After that, you use the C++ exception-handling facilities to add code for those unusual cases. Exception handling is commonly used to handle error situations, but perhaps a better way to view exceptions is as a way to handle “exceptional situations.” After all, if your code correctly handles an “error,” then it no longer is an error.

Perhaps the most important use of exceptions is to deal with functions that have some special case that is handled differently depending on how the function is used. Perhaps the function will be used in many programs, some of which will handle the special case in one way and some of which will handle it in some other way. For example, if there is a division by zero in the function, then it may turn out that for some invocations of the function, the program should end, but for other invocations of the function something else should happen. You will see that such a function can be defined to throw an exception if the special case occurs, and that exception will allow the special case to be handled outside of the function. That way, the special case can be handled differently for different invocations of the function.

In C++, exception handling proceeds as follows: Either some library software or your code provides a mechanism that signals when something unusual happens. This is called throwing an exception. At another place in your program, you place the code that deals with the exceptional case. This is called handling the exception. This method of programming makes for cleaner code. Of course, we still need to explain the details of how you do this in C++.

Prerequisites

With the exception of one subsection that can be skipped, Section 16.1 uses material only from Chapters 2 to 6 and 10 to 11. The Pitfall subsection of Section 16.1 entitled “Exception Specification in Derived Classes” uses material from Chapter 15. This Pitfall subsection can be skipped without loss of continuity.

With the exception of one subsection that can be skipped, Section 16.2 uses material only from Chapters 2 to 8 and 10 to 12 and Section 15.1 of Chapter 15 in addition to Section 16.1. The subsection of Section 16.2 entitled “Testing for Available Memory” uses material from Chapter 15. This subsection can be skipped without loss of continuity.