At a certain level of the program only a limited set of handlers may actually
be required. Exceptions whose types belong to that limited set are processed,
all other exceptions are passed on to exception handlers of an outer level
tt(try) block.

An intermediate type of exception handling may be implemented using the
default exception handler, which must be (due to the hierarchal nature of
exception catchers, discussed in section ref(EXCEPTIONCATCH)) placed beyond
all other, more specific exception handlers.

This default exception handler cannot determine the actual type of the thrown
exception and cannot determine the exception's value but it may execute some
statements, and thus do some default processing. Moreover, the caught
exception is not lost, and the default exception handler may use the empty
tt(throw) statement (see section ref(EMPTYTHROW)) to pass the exception on to
an outer level, where it's actually processed.  Here is an example showing
this use of a default exception handler:
    verbinclude(-a examples/defaultcatch.cc)
    The program's output illustrates that an empty tt(throw) statement in a
default exception handler throws the received exception to the next (outer)
level of exception catchers, keeping type and value of the thrown exception.

Thus, basic or generic exception handling can be accomplished at an inner
level, while specific handling, based on the type of the thrown expression,
can be provided at an outer level. Additionally, particularly in
multi-threaded programs (cf. chapter ref(THREADING)), thrown exceptions can be
transferred between threads after converting tt(std::exception) objects to
tt(std::exception_ptr) objects. This proceduce can even be used from inside
the default catcher. Refer to section ref(EXCPTR) for further coverage of the
class tt(std::exception_ptr).

