1
Course: Object Oriented Programming using C++ (22CAU04A)
Programme (s) : BCA
Class : I B.C.A ‘A’
Semester : II
Unit & Lecture : 3 & 28
Facilitator : Prof. J. JELSTEEN
Topic to be Discussed
Exception Handling
Outline
• What exceptions are and when to use them
• Using try, catch and throw to detect, handle and
indicate exceptions, respectively
• To process uncaught and unexpected exceptions
• To declare new exception classes
• How stack unwinding enables exceptions not
caught in one scope to be caught in another scope
• To handle new failures
• To understand the standard exception hierarchy
Introduction
• Exceptions
• Indicate problems that occur during a program’s
execution
• Occur infrequently
• Exception handling
• Can resolve exceptions
• Allow a program to continue executing or
• Notify the user of the problem and
• Terminate the program in a controlled manner
• Makes programs robust and fault-tolerant
Exception Handling in C++
• A standard mechanism for processing errors :
• Especially important when working on a project with a
large team of programmers
• C++ exception handling is much like Java’s
• Java’s exception handling is much like C++
Fundamental Philosophy
• Mechanism for sending an exception signal up the call
stack - Regardless of intervening calls
• Note: there is a mechanism based on same philosophy in
C
• setjmp(), longjmp()
• See man pages
Traditional Exception Handling
• Intermixing program and error-handling logic
Pseudocode outline
Perform a task
If the preceding task did not execute correctly Perform error processing
Perform next task
If the preceding task did not execute correctly
Perform error processing
• Makes the program difficult to read, modify, maintain
and debug
• Impacts performance
Fundamental Philosophy
• Remove error-handling code from the program
execution’s “main line”
• Programmers can handle any exceptions they choose
• All exceptions
• All exceptions of a certain type
• All exceptions of a group of related types
Fundamental Philosophy
• Programs can
• Recover from exceptions
• Hide exceptions
• Pass exceptions up the “chain of command”
• Ignore certain exceptions and let someone else
handle them
Fundamental Philosophy
• An exception is a class
• Usually derived from one of the system’s exception
base classes
• If an exceptional or error situation occurs, program
throws an object of that class
• Object crawls up the call stack
• A calling program can choose to catch exceptions of
certain classes
• Take action based on the exception object
30
31 // enable user to enter two integers to divide
32 while ( cin >> number1 >> number2 )
33 {
34 // try block contains code that might throw exception
35 // and code that should not execute if an exception occurs
36 try
37 {
38 result = quotient( number1, number2 );
39 cout << "The quotient is: " << result << endl;
40 } // end try
41
42 // exception handler handles a divide-by-zero exception
43 catch ( DivideByZeroException ÷ByZeroException )
44 {
45 cout << "Exception occurred: "
46 << divideByZeroException.what() << endl;
47 } // end catch
48
49 cout << "\nEnter two integers (end-of-file to end): ";
50 } // end while
51
52 cout << endl;
53 return 0; // terminate normally
54 } // end main
try Blocks
• Keyword try followed by braces ({})
• Should enclose
• Statements that might cause exceptions
• Statements that should be skipped in case of an
exception
Software Engineering Observation
• Exceptions may surface
• through explicitly mentioned code in a try block,
• through calls to other functions and
• through deeply nested function calls initiated by code
in a try block.
Catch Handlers
• Immediately follow a try block
• One or more catch handlers for each try block
• Keyword catch
• Exception parameter enclosed in parentheses
• Represents the type of exception to process
• Can provide an optional parameter name to interact with
the caught exception object
• Executes if exception parameter type matches the exception
thrown in the try block
• Could be a base class of the thrown exception’s class
Catch Handlers
try {
// code to try
}
catch (exceptionClass1 &name1) {
// handle exceptions of exceptionClass1
}
catch (exceptionClass2 &name2) {
// handle exceptions of exceptionClass2
}
catch (exceptionClass3 &name3) {
// handle exceptions of exceptionClass3
}
...
/* code to execute if
no exception or
catch handler handled exception*/
Common Programming Errors
Syntax error to place code between a try block
and its corresponding catch handlers
Each catch handler can have only a single
parameter
• Specifying a comma-separated list of exception parameters
is a syntax error
• Logic error to catch the same type in two
different catch handlers following a single try
block
Next Session
Exception Handling
Thank You
