cpphtp9_Exception handling in c++ .ppt

C++ How to Program, 9/e
©1992-2014 by Pearson Education, Inc. All Rights Reserved.

©1992-2014 by Pearson Education, Inc. All
Rights Reserved.

 An exception is an indication of a problem that occurs
during a program’s execution.
 Exception handling enables you to create applications
that can resolve (or handle) exceptions.
 In many cases, this allows a program to continue
executing as if no problem had been encountered.
 The features presented in this chapter enable you to
write robust and fault-tolerant programs that can deal
with problems that may arise and continue executing or
terminate gracefully.
Rights Reserved.

 Let’s consider a simple example of exception handling
(Figs. 17.1–17.2).
 We show how to deal with a common arithmetic
problem—division by zero.
 Division by zero using integer arithmetic typically
causes a program to terminate prematurely.
 In floating-point arithmetic, many C++
implementations allow division by zero, in which case
positive or negative infinity is displayed as INF or -
INF, respectively.
Rights Reserved.

 In this example, we define a function named
quotient that receives two integers input by the user
and divides its first int parameter by its second int
parameter.
 Before performing the division, the function casts the
first int parameter’s value to type double.
 Then, the second int parameter’s value is promoted to
type double for the calculation.
 So function quotient actually performs the division
using two double values and returns a double
result.
Rights Reserved.

 Although division by zero is allowed in floating-point arithmetic,
for the purpose of this example we treat any attempt to divide by
zero as an error.
 Thus, function quotient tests its second parameter to ensure
that it isn’t zero before allowing the division to proceed.
 If the second parameter is zero, the function uses an exception to
indicate to the caller that a problem occurred.
 The caller (main in this example) can then process the exception
and allow the user to type two new values before calling function
quotient again.
 In this way, the program can continue to execute even after an
improper value is entered, thus making the program more robust.
Rights Reserved.

 DivideByZeroException.h (Fig. 17.1) defines
an exception class that represents the type of the
problem that might occur in the example, and
fig17_02.cpp (Fig. 17.2) defines the quotient
function and the main function that calls it.
 Function main contains the code that demonstrates
exception handling.
Rights Reserved.

Defining an Exception Class to Represent the Type of Problem That Might Occur
Figure 17.1 defines class DivideByZeroException as a
derived class of Standard Library class runtime_error
(from header file <stdexcept>).
Class runtime_error—a derived class of exception
(from header file <exception>)—is the C++ standard base
class for representing runtime errors.
Class exception is the standard C++ base class for
exception in the C++ Standard Library.
◦ Section 17.10 discusses class exception and its derived classes in
detail.
Rights Reserved.

 A typical exception class that derives from the
runtime_error class defines only a constructor (e.g., lines
11–12) that passes an error-message string to the base-class
runtime_error constructor.
 Every exception class that derives directly or indirectly from
exception contains the virtual function what, which
returns an exception object’s error message.
 You are not required to derive a custom exception class, such as
DivideByZeroException, from the standard exception
classes provided by C++.
◦ Doing so allows you to use the virtual function what to obtain an
appropriate error message.
 We use an object of this DivideByZeroException class in
Fig. 17.2 to indicate when an attempt is made to divide by zero.
Rights Reserved.

Demonstrating Exception Handling
Fig. 17.2 uses exception handling to wrap code that might
throw a DivideByZeroException and to handle that
exception, should one occur.
Function quotient divides its first parameter
(numerator) by its second parameter (denominator).
Assuming that the user does not specify 0 as the denominator
for the division, quotient returns the division result.
However, if the user inputs 0 for the denominator, function
quotient throws an exception.
Rights Reserved.

Enclosing Code in a try Block
Exception handling is geared to situations in which the function
that detects an error is unable to handle it.
try blocks enable exception handling.
The try block encloses statements that might cause exceptions
and statements that should be skipped if an exception occurs.
In this example, because the invocation of function quotient
(line 34) can throw an exception, we enclose this function
invocation in a try block.
Enclosing the output statement (line 35) in the try block ensures
that the output will occur only if function quotient returns a
result.
Rights Reserved.

Defining a catch Handler to Process a DivideByZeroException
Exceptions are processed by catch handlers.
At least one catch handler (lines 37–41) must immediately
follow each try block.
An exception parameter should always be declared as a
reference to the type of exception the catch handler can process
(DivideByZeroException in this case)—this prevents
copying the exception object when it’s caught and allows a catch
handler to properly catch derived-class exceptions as well.
When an exception occurs in a try block, the catch handler
that executes is the first one whose type matches the type of the
exception that occurred (i.e., the type in the catch block
matches the thrown exception type exactly or is a direct or
indirect base class of it).
Rights Reserved.

 If an exception parameter includes an optional
parameter name, the catch handler can use that
parameter name to interact with the caught exception in
the body of the catch handler, which is delimited by
braces ({ and }).
 A catch handler typically reports the error to the user,
logs it to a file, terminates the program gracefully or
tries an alternate strategy to accomplish the failed task.
 In this example, the catch handler simply reports that
the user attempted to divide by zero. Then the program
prompts the user to enter two new integer values.
Rights Reserved.

Termination Model of Exception Handling
If an exception occurs as the result of a statement in a try block,
the try block expires (i.e., terminates immediately).
Next, the program searches for the first catch handler that can
process the type of exception that occurred.
The program locates the matching catch by comparing the
thrown exception’s type to each catch’s exception-parameter
type until the program finds a match.
A match occurs if the types are identical or if the thrown
exception’s type is a derived class of the exception-parameter
type.
When a match occurs, the code in the matching catch handler
executes.
Rights Reserved.

 When a catch handler finishes processing by reaching its
closing right brace (}), the exception is considered handled and
the local variables defined within the catch handler (including
the catch parameter) go out of scope.
 Program control does not return to the point at which the
exception occurred (known as the throw point), because the try
block has expired.
 Rather, control resumes with the first statement after the last
catch handler following the try block.
 This is known as the termination model of exception handling.
 As with any other block of code, when a try block terminates,
local variables defined in the block go out of scope.
Rights Reserved.

 If the try block completes its execution successfully (i.e.,
no exceptions occur in the try block), then the program
ignores the catch handlers and program control continues
with the first statement after the last catch following that
try block.
 If an exception that occurs in a try block has no matching
catch handler, or if an exception occurs in a statement that
is not in a try block, the function that contains the
statement terminates immediately, and the program attempts
to locate an enclosing try block in the calling function.
 This process is called stack unwinding and is discussed in
Section 17.4.
Rights Reserved.

Flow of Program Control When the User Enters a
Denominator of Zero
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.
Central characteristic of exception handling: If your program
explicitly throws an exception, it should do so before the error
has an opportunity to occur.
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.
Rights Reserved.

 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.
 The exception object is maintained by the exception-handling
mechanism.
Rights Reserved.

 A function might use a resource—like a file—and might want to
release the resource (i.e., close the file) if an exception occurs.
 An exception handler, upon receiving an exception, can release
the resource then notify its caller than an exception occurred by
rethrowing the exception via the statement
 throw;
 Regardless of whether a handler can process 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.
Rights Reserved.

 The program of Fig. 17.3 demonstrates rethrowing an
exception.
 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 16 and 35).
Rights Reserved.

 When an exception is thrown but not caught in a particular scope, the
function call stack is “unwound,” and an attempt is made to catch the
exception in the next outer try…catch block.
 Unwinding the function call stack means that the function in which the
exception was not caught terminates, all local variables that have
completed intitialization in that function are destroyed and control
returns to the statement that originally invoked that function.
 If a try block encloses that statement, an attempt is made to catch
the exception.
 If a try block does not enclose that statement, stack unwinding occurs
again.
 If no catch handler ever catches this exception, the program
terminates.
 The program of Fig. 17.4 demonstrates stack unwinding.
Rights Reserved.

 Line 13 of function3 throws a runtime_error object.
 However, because no try block encloses the throw statement in line
13, stack unwinding occurs—function3 terminates at line 13, then
returns control to the statement in function2 that invoked
function3 (i.e., line 20).
 Because no try block encloses line 20, stack unwinding occurs again
—function2 terminates at line 20 and returns control to the
statement in function1 that invoked function2 (i.e., line 27).
 Because no try block encloses line 27, stack unwinding occurs one
more time—function1 terminates at line 27 and returns control to
the statement in main that invoked function1 (i.e., line 37).
 The try block of lines 34–38 encloses this statement, so the first
matching catch handler located after this try block (line 39–43)
catches and processes the exception.
Rights Reserved.

 Exception handling is designed to process synchronous
errors, which occur when a statement executes, such as out-
of-range array subscripts, arithmetic overflow (i.e., a value
outside the representable range of values), division by zero,
invalid function parameters and unsuccessful memory
allocation (due to lack of memory).
 Exception handling is not designed to process errors
associated with asynchronous events (e.g., disk I/O
completions, network message arrivals, mouse clicks and
keystrokes), which occur in parallel with, and independent
of, the program’s flow of control.
Rights Reserved.

 Exception-handling also is useful for processing
problems that occur when a program interacts with
software elements, such as member functions,
constructors, destructors and classes.
 Software elements often use exceptions to notify
programs when problems occur.
 This enables you to implement customized error
handling for each application.
Rights Reserved.

 Complex applications normally consist of predefined
software components and application-specific
components that use the predefined components.
 When a predefined component encounters a problem,
that component needs a mechanism to communicate
the problem to the application-specific component—
the predefined component cannot know in advance how
each application processes a problem that occurs.
Rights Reserved.

C++11: Declaring Functions That Do Not Throw Exceptions
As of C++11, if a function does not throw any exceptions and does
not call any functions that throw exceptions, you should explicitly
state that a function does not throw exceptions.
This indicates to client-code programmers that there’s no need to
place calls to the function in a try block.
Add noexcept to the right of the function’s parameter list in both
the prototype and the definition.
For a const member function, place noexcept after const.
If a function that’s declared noexcept calls another function that
throws an exception or executes a throw statement, the program
terminates.
Rights Reserved.

 What happens when an error is detected in a constructor?
 For example, how should an object’s constructor respond
when it receives invalid data?
 Because the constructor cannot return a value to indicate an
error, we must choose an alternative means of indicating
that the object has not been constructed properly.
 One scheme is to return the improperly constructed object
and hope that anyone using it would make appropriate tests
to determine that it’s in an inconsistent state.
 Another scheme is to set some variable outside the
constructor.
Rights Reserved.

 The preferred alternative is to require the constructor to
throw an exception that contains the error information, thus
offering an opportunity for the program to handle the failure.
 Before an exception is thrown by a constructor, destructors
are called for any member objects whose constructors have
run to completion as part of the object being constructed.
 Destructors are called for every automatic object constructed
in a try block before the exception is caught.
 Stack unwinding is guaranteed to have been completed at the
point that an exception handler begins executing.
 If a destructor invoked as a result of stack unwinding throws
an exception, the program terminates.
 This has been linked to various security attacks.
Rights Reserved.

 If an object has member objects, and if an exception is
thrown before the outer object is fully constructed, then
destructors will be executed for the member objects
that have been constructed prior to the occurrence of
the exception.
 If an array of objects has been partially constructed
when an exception occurs, only the destructors for the
constructed objects in the array will be called.
Rights Reserved.

Initializing Local Objects to Acquire Resources
An exception could preclude the operation of code that would
normally release a resource (such as memory or a file), thus
causing a resource leak that prevents other programs from
acquiring the resource.
◦ One technique to resolve this problem is to initialize a local
object to acquire the resource.
When an exception occurs, the destructor for that object will be
invoked and can free the resource.
Rights Reserved.

 Various exception classes can be derived from a
common base class, as we discussed in Section 17.2,
when we created class DivideByZeroException
as a derived class of class exception.
 If a catch handler catches a reference to an exception
object of a base-class type, it also can catch a
reference to all objects of classes publicly derived from
that base class—this allows for polymorphic processing
of related exceptions.
Rights Reserved.

 When operator new fails, it throws a bad_alloc
exception (defined in header file <new>).
 In this section, we present two examples of new
failing.
◦ The first uses the version of new that throws a bad_alloc
exception when new fails.
◦ The second uses function set_new_handler to handle
new failures.
◦ [Note: The examples in Figs. 17.5–17.6 allocate large amounts
of dynamic memory, which could cause your computer to
become sluggish.]
Rights Reserved.

new Throwing bad_alloc on Failure
Figure 17.5 demonstrates new implicitly throwing
bad_alloc on failure to allocate the requested
memory.
The for statement (lines 16–20) inside the try block
should loop 50 times and, on each pass, allocate an array
of 50,000,000 double values.
If new fails and throws a bad_alloc exception, the
loop terminates, and the program continues in line 22,
where the catch handler catches and processes the
exception.
Rights Reserved.

 Lines 24–25 print the message "Exception occurred:"
followed by the message returned from the base-class-
exception version of function what (i.e., an
implementation-defined exception-specific message, such as
“bad allocation " in Microsoft Visual C++).
 The output shows that the program performed only four
iterations of the loop before new failed and threw the
bad_alloc exception.
 Your output might differ based on the physical memory, disk
space available for virtual memory on your system and the
compiler you are using.
Rights Reserved.

new Returning nullptr on Failure
The C++ standard specifies that programmers can use an
older version of new that returns nullptr upon failure.
For this purpose, header <new> defines object nothrow (of
type nothrow_t), which is used as follows:
 double *ptr = new( nothrow ) double[ 50000000 ];
The preceding statement uses the version of new that does
not throw bad_alloc exceptions (i.e., nothrow) to
allocate an array of 50,000,000 doubles.
Rights Reserved.

Handling new Failures Using Function set_new_handler
Function set_new_handler (prototyped in standard header
file <new>) takes as its argument a pointer to a function that takes
no arguments and returns void.
◦ This pointer points to the function that will be called if new fails.
◦ This provides you with a uniform approach to handling all new failures,
regardless of where a failure occurs in the program.
Once set_new_handler registers a new handler in the
program, operator new does not throw bad_alloc on failure;
rather, it defers the error handling to the new-handler function.
If new fails to allocate memory and set_new_handler did not
register a new-handler function, new throws a bad_alloc
exception.
If new fails to allocate memory and a new-handler function has
been registered, the new-handler function is called.
Rights Reserved.

 The new-handler function should perform one of the following
tasks:
◦ Make more memory available by deleting other dynamically allocated
memory (or telling the user to close other applications) and return to
operator new to attempt to allocate memory again.
◦ Throw an exception of type bad_alloc.
◦ Call function abort or exit (both found in header file <cstdlib>)
to terminate the program. These were introduced in Section 9.7.
 Figure 17.6 demonstrates set_new_handler.
 Function customNewHandler (lines 9–13) prints an error
message (line 11), then calls abort (line 12) to terminate the
program.
 The output shows that the loop iterated four times before new
failed and invoked function customNewHandler.
Rights Reserved.

 A common programming practice is to allocate
dynamic memory, assign the address of that memory to
a pointer, use the pointer to manipulate the memory
and deallocate the memory with delete when the
memory is no longer needed.
 If an exception occurs after successful memory
allocation but before the delete statement executes, a
memory leak could occur.
 C++ 11 provides class template unique_ptr in
header file <memory> to deal with this situation.
Rights Reserved.

 An object of class unique_ptr maintains a pointer to
dynamically allocated memory.
 When an unique_ptr object destructor is called (for example,
when an unique_ptr object goes out of scope), it performs a
delete operation on its pointer data member.
 Class template unique_ptr provides overloaded operators *
and -> so that an unique_ptr object can be used just as a
regular pointer variable is.
 Figure 17.9 demonstrates an unique_ptr object that points to
a dynamically allocated object of class Integer (Figs. 17.7–
17.8).
Rights Reserved.

 Because ptrToInteger is a local automatic variable
in main, ptrToInteger is destroyed when main
terminates.
 The unique_ptr destructor forces a delete of the
Integer object pointed to by ptrToInteger,
which in turn calls the Integer class destructor.
 The memory that Integer occupies is released,
regardless of how control leaves the block (e.g., by a
return statement or by an exception).
 Most importantly, using this technique can prevent
memory leaks.
Rights Reserved.

unique_ptr Notes
The class is called unique_ptr because only one
unique_ptr at a time can own a dynamically allocated object.
By using its overloaded assignment operator or copy
constructor, an unique_ptr can transfer ownership of the
dynamic memory it manages.
Rights Reserved.

 The last unique_ptr object that maintains the pointer to the
dynamic memory will delete the memory.
 This makes unique_ptr an ideal mechanism for returning
dynamically allocated memory to client code.
 When the unique_ptr goes out of scope in the client code,
the unique_ptr’s destructor destroys the dynamically
allocated object and deletes its memory.
Rights Reserved.

unique_ptr to a Built-In Array
You can also use a unique_ptr to manage a dynamically
allocated built-in array.
For example, consider the statement
unique_ptr< string[] > ptr( new string[ 10 ] );
which dynamically allocates an array of 10 strings managed by
ptr.
The type string[] indicates that the managed memory is a
built-in array containing strings.
Rights Reserved.

 When a unique_ptr that manages an array goes out of scope
it deletes the memory with delete [] so that every element
of the array receives a destructor call.
 A unique_ptr that manages an array provides an
overloaded [] operator for accessing the array’s elements.
 For example, the statement
ptr[ 2 ] = "hello";
 assigns "hello" to the string at ptr[2] and the
statement
cout << ptr[ 2 ] << endl;
 displays that string.
Rights Reserved.

 Experience has shown that exceptions fall nicely into a
number of categories.
 The C++ Standard Library includes a hierarchy of
exception classes, some of which are shown in
Fig. 17.10.
 As we first discussed in Section 17.2, this hierarchy is
headed by base-class exception (defined in header
file <exception>), which contains virtual
function what that derived classes can override to
issue appropriate error messages.
Rights Reserved.

 Immediate derived classes of base-class exception
include runtime_error and logic_error (both
defined in header <stdexcept>), each of which has
several derived classes.
 Also derived from exception are the exceptions
thrown by C++ operators—for example, bad_alloc
is thrown by new (Section 17.8), bad_cast is thrown
by dynamic_cast (Chapter 12) and bad_typeid
is thrown by typeid (Chapter 12).
Rights Reserved.

 Class logic_error is the base class of several standard
exception classes that indicate errors in program logic.
◦ For example, class invalid_argument indicates that a function
received an invalid argument.
◦ Proper coding can, of course, prevent invalid arguments from
reaching a function.
 Class length_error indicates that a length larger than
the maximum size allowed for the object being manipulated
was used for that object.
 Class out_of_range indicates that a value, such as a
subscript into an array, exceeded its allowed range of
values.
Rights Reserved.

 Class runtime_error, which we used briefly in
Section 17.4, is the base class of several other standard
exception classes that indicate execution-time errors.
◦ For example, class overflow_error describes an
arithmetic overflow error (i.e., the result of an arithmetic
operation is larger than the largest number that can be stored in
the computer) and class underflow_error describes an
arithmetic underflow error (i.e., the result of an arithmetic
operation is smaller than the smallest number that can be
stored in the computer).
Rights Reserved.

cpphtp9_Exception handling in c++ .ppt

Recommended

More Related Content

Similar to cpphtp9_Exception handling in c++ .ppt (20)

More from ansariparveen06 (20)

Recently uploaded (20)

cpphtp9_Exception handling in c++ .ppt