If
you encounter an exceptional situation in your code – that is, one where
you don’t have enough information in the current context to decide what
to do – you can send information about the error into a larger context by
creating an object containing that information and “throwing” it
out of your current context. This is called
throwing
an exception
.
Here’s what it looks like:
throw
myerror(“something bad happened”);
myerror
is an ordinary class, which takes a
char*
as its argument. You can use any type when you throw (including built-in
types), but often you’ll use special types created just for throwing
exceptions.
The
keyword
throw
causes a number of relatively magical things to happen. First it creates an
object that isn’t there under normal program execution, and of course the
constructor is called for that object. Then the object is, in effect,
“returned” from the function, even though that object type
isn’t normally what the function is designed to return. A simplistic way
to think about exception handling is as an alternate return mechanism, although
you get into trouble if you take the analogy too far – you can also exit
from ordinary scopes by throwing an exception. But a value is returned, and the
function or scope exits.
Any
similarity to function returns ends there because
where
you return to is someplace completely different than for a normal function
call. (You end up in an appropriate exception handler that may be miles away
from where the exception was thrown.) In addition, only objects that were
successfully created at the time of the exception are destroyed (unlike a
normal function return that assumes all the objects in the scope must be
destroyed). Of course, the exception object itself is also properly cleaned up
at the appropriate point.
In
addition, you can throw as many different types of objects as you want.
Typically, you’ll throw a different type for each different type of
error. The idea is to store the information in the object and the
type
of object, so someone in the bigger context can figure out what to do with your
exception.