Rethrowing an Exception

It is possible that an exception handler, upon receiving an exception, might decide either that it cannot process that exception or that it can process the exception only partially. In such cases, the exception handler can defer the exception handling (or perhaps a portion of it) to another exception handler. In either case, the handler achieves this by rethrowing the exception via the statement

throw;

Regardless of whether a handler can process (even partially) an exception, the handler can rethrow the exception for further processing outside the handler. The next enclosing try block detects the rethrown exception, which a catch handler listed after that enclosing try block attempts to handle.

Common Programming Error 16.6

Executing an empty tHRow statement that is situated outside a catch handler causes a call to function terminate, which abandons exception processing and terminates the program immediately.

The program of Fig. 16.3 demonstrates rethrowing an exception. In main's try block (lines 3237), line 35 calls function throwException (lines 1127). The tHRowException function also contains a TRy block (lines 1418), from which the tHRow statement at line 17 throws an instance of standard-library-class exception. Function tHRowException's catch handler (lines 1924) catches this exception, prints an error message (lines 2122) and rethrows the exception (line 23). This terminates function throwException and returns control to line 35 in the try... catch block in main. The try block terminates (so line 36 does not execute), and the catch handler in main (lines 3841) catches this exception and prints an error message (line 40). [Note: Since we do not use the exception parameters in the catch handlers of this example, we omit the exception parameter names and specify only the type of exception to catch (lines 19 and 38).]

---

Figure 16.3. Rethrowing an exception.

(This item is displayed on pages 820 - 821 in the print version)

 1 // Fig. 16.3: Fig16_03.cpp
 2 // Demonstrating exception rethrowing.
 3 #include 
 4 using std::cout;
 5 using std::endl;
 6
 7 #include 
 8 using std::exception;
 9
10 // throw, catch and rethrow exception
11 void throwException()
12 {
13 // throw exception and catch it immediately
14 try
15 {
16 cout << " Function throwException throws an exception
";
17 throw exception(); // generate exception
18 } // end try
19 catch ( exception & ) // handle exception
20 {
21 cout << " Exception handled in function throwException"
22 << "
 Function throwException rethrows exception";
23 throw; // rethrow exception for further processing
24 } // end catch
25
26 cout << "This also should not print
";
27 } // end function throwException
28
29 int main()
30 {
31 // throw exception
32 try
33 {
34 cout << "
main invokes function throwException
";
35 throwException();
36 cout << "This should not print
";
37 } // end try
38 catch ( exception & ) // handle exception
39 {
40 cout << "

Exception handled in main
";
41 } // end catch
42
43 cout << "Program control continues after catch in main
";
44 return 0;
45 } // end main

 

 main invokes function throwException
 Function throwException throws an exception
 Exception handled in function throwException
 Function throwException rethrows exception

 Exception handled in main
 Program control continues after catch in main