Now consider the case in which the user inputs the numerator 100
and the denominator 0
. In line 13, quotient
determines that the denominator
is zero, which indicates an attempt to divide by zero. Line 14 throws an exception, which we represent as an object of class DivideByZeroException
(Fig. 17.1).
To throw an exception, line 14 in Fig. 17.2 uses keyword throw followed by an operand of the type of exception to throw. Normally, a throw
statement specifies one operand. (In Section 17.3, we discuss how to use a throw
statement with no operand.) The operand of a throw
can be of any type (but it must be copy constructable). If the operand is an object, we call it an exception object—in this example, the exception object is of type DivideByZeroException
. However, a throw
operand also can assume other values, such as the value of an expression that does not result in an object of a class (e.g., throw x > 5
) or the value of an int
(e.g., throw 5
). The examples in this chapter focus exclusively on throwing objects of exception classes.
Error-Prevention Tip 17.3
In general, you should throw only objects of exception class types.
As part of throwing an exception, the throw
operand is created and used to initialize the parameter in the catch
handler, which we discuss momentarily. The throw
statement in line 14 creates a DivideByZeroException
object. When line 14 throws the exception, function quotient
exits immediately. So, line 14 throws the exception before function quotient
can perform the division in line 17. This is a central characteristic of exception handling: If your program explicitly throws an exception, it should do so before the error has an opportunity to occur.
Because we enclosed the call to quotient
(line 34) in a try
block, program control enters the catch
handler (lines 37–41) that immediately follows the try
block. This catch
handler serves as the exception handler for the divide-by-zero exception. In general, when an exception is thrown within a try
block, the exception is caught by a catch
handler that specifies the type matching the thrown exception. In this program, the catch
handler specifies that it catches DivideByZeroException
objects—this type matches the object type thrown in function quotient
. Actually, the catch
handler catches a reference to the DivideByZeroException
object created by function quotient
’s throw
statement (line 14), so that the catch
handler does not make a copy of the exception object.
The catch
’s body (lines 39–40) prints the error message returned by function what
of base-class runtime_error
—i.e., the string that the DivideByZeroException
constructor (lines 11–12 in Fig. 17.1) passed to the runtime_error
base-class constructor.
Good Programming Practice 17.1
Associating each type of runtime error with an appropriately named exception type improves program clarity.