Chapter 19

Exception Handling

19.1   INTRODUCTION

While writing large programs, a programmer usually makes many mistakes. Due to this, bugs occur even in the released softwares. Developing an error-free program is the only objective and intention of the programmer. Programmers should take care to prevent errors. Errors can be trapped using exception-handling features.

A few languages support exception-handling features. Without this feature, the programmers should find out errors on their own. The errors may be logical errors or syntactic mistakes (syntax mistakes). The logical error remains in the program due to a poor understanding of the program. The syntax mistakes made are due to a lack of understanding of the programming language. C++ provides an exception-handling procedure to reduce the errors that the programmer makes.

The programmer always faces unusual errors while writing programs. An exception is an abnormal termination of the program, which is executed in a program at run time or it may be called at run time when the error occurs. The exception contains warning messages such as invalid argument, insufficient memory, and division by zero. ANSI C++ is built in language functions for trapping errors and controlling exceptions. All C++ compilers support this newly added facility.

19.2   PRINCIPLES OF EXCEPTION HANDLING

Similar to errors, exceptions are also of two types. They are as follows:

• Synchronous exceptions
• Asynchronous exceptions

C++ has a well-organized, object-oriented method to control run-time errors that occur in the program. The goal of exception handling is to create a routine that detects and sends an exceptional condition in order to execute suitable actions. The routine needs to carry out the following responsibilities:

1. Detect the problem
2. Warn that an error has been detected
3. Accept the error message
4. Perform accurate actions without troubling the user

An exception is an object. It is sent from the part of the program where an error occurs to the part of the program that is going to control the error. An exception provides an explicit pathway that contains errors to the code which controls these errors.

19.3   THE KEYWORDS try, throw, AND catch

The exception-handling technique passes the control of a program from a location of exception in a program to an exception-handler routine linked with the try block. An exception-handler routine can only be called by the throw statement.

• try: The try keyword is followed by a series of statements enclosed in curly braces.

   

  Syntax of try statement

   

  try

  {

  statement 1;

  statement 2;

  }

• throw: The function of the throw statement is to send the exception found. The declaration of the throw statement is as follows:

   

  Syntax of throw statement

   

  throw (excep);

  throw excep;

  throw // re-throwing of an exception

  The argument excep is allowed to be of any type, and it may be a constant. The catch block associated with the try block catches the exception thrown. The control is transferred from the try block to the catch block. The throw statement can be placed in a function or is a nested loop, but it should be in the try block. After throwing the exception, control passes to the catch statement.

• catch: Similar to the try block, the catch block also contains a series of statements enclosed in curly braces. It also contains an argument of an exception type in parentheses.

   

  Syntax of catch statement

   

  try

  {

  Statement 1;

  Statement 2;

  }

  catch ( argument)

  {

  statement 3; // Action to be taken

  }

  When an exception is found, the catch block is executed. The catch statement contains an argument of exception type, and it is optional. When an argument is declared, the argument can be used in the catch block. After the execution of the catch block, the statements inside the blocks are executed. In case no exception is caught, the catch block is ignored, and if a mismatch is found, the program is terminated.

19.4   GUIDELINES FOR EXCEPTION HANDLING

The C++ exception-handling mechanism provides three keywords; they are try, throw, and catch. The keyword try is used at the starting of the exception. The throw block is present inside the try block. Immediately after the try block, the catch block is present. Figure 19.1 shows the try, catch, and throw statements.

As soon as an exception is found, the throw statement inside the try block throws an exception (a message for the catch block that an error has occurred in the try block statements). Only errors occurring inside the try block are used to throw exceptions. The catch block receives the exception that is sent by the throw block. The general form of the statement is as per Figure 19.2.

When the try block passes an exception using the throw statement, the control of the program passes to the catch block. The data type used by throw and catch statements should be same; otherwise, the program is aborted using the abort() function, which is executed implicitly by the compiler. When no error is found and no exception is thrown, in such a situation, the catch block is disregarded, and the statement after the catch block is executed.

Fig. 19.1 Exception mechanism

Fig. 19.2 try, throw, and catch blocks

Explanation: In the above program, the values of x and y are entered. The conditional operator tests the two numbers; if x is greater than y, zero is assigned to j; otherwise, it is one. In the try block, the if condition checks the value of j; the subtraction is carried out when j is zero; otherwise, the else block throws the exception. The catch statement catches the exception thrown. The output of the program is shown above.

 

Explanation: In the above program, the function sqr() is defined. The function sqr() reads an integer through the keyboard and displays its square. Before calculating the square, the if statement checks the number. If it is greater than zero, then the if block calculates the square and displays it; otherwise, the else block throws the exception. In the function main(), in the try block, the function is called twice. In case an exception is thrown from the function sqr(), the catch statement catches it, and the catch block is executed. This happens only when the user enters the number 0 or less than zero. If the user enters 0 in the first call, then the exception is thrown, and the catch block is executed. The compiler ignores the next statement of the try block. Once the control skips from the try block, it never comes back to execute the remaining statements. Thus, in this program if in the first call the user enters 0, then the second call of the function sqr() is not taken into account.

19.5   MULTIPLE catch STATEMENTS

We can also define multiple catch blocks; in the try block, such programs also contain multiple throw statements based on certain conditions. The format of multiple catch statements is as follows:

 

As soon as an exception is thrown, the compiler searches for an appropriate matching catch block. The matching catch block is executed, and control passes to the successive statement after the last catch block. In case no match is found, the program is terminated. In a multiple catch statement, if objects of many catch statements are similar to the type of an exception, in such a situation, the first catch block that matches is executed.

 

Explanation: In the above program, the function num() contains the try block with multiple catch blocks. In the function main(), the user-defined function num() is invoked with one argument. The if statement within the try block checks the number to see whether it is positive, negative, or zero. According to this, an exception is thrown, and the respective catch block is executed. Here, in the throw statement, objects of different data types such as int, char, and double are used to avoid ambiguity.

19.6   CATCHING MULTIPLE EXCEPTIONS

It is also possible to define a single or default catch block from one or more exceptions of different types. In such a situation, a single catch block is used to catch the exceptions thrown by the multiple throw statements.

 

   catch

   {

   // Statements for handling

   // all exceptions

   }

 

Explanation: The above program is similar to the previous one. Here, only one difference is observed and that is, instead of multiple catch blocks, a single catch block is defined. For all the exceptions thrown, the same catch block is executed. It is a generic type of catch block. The statement catch catches all the exceptions thrown.

19.7   RE-THROWING EXCEPTION

It is also possible to again pass the exception received to another exception handler; that is, an exception is thrown from the catch block; this is known as the re-throwing exception. The following statement accomplishes this:

throw;

The above throw statement is used without any argument. This statement throws the exception caught to the next try catch statement. The following program illustrates this:

 

Explanation: In the above program, two try blocks are defined. One is defined in the function sub(), and the other is defined in the function main(). The sub() function has two integer arguments. When the sub() function is invoked, two integer values are sent to this function. The if statement in the try block of the sub() function checks whether the value of the first variable, that is, j is zero or non-zero. If it is non-zero, subtraction is carried out; otherwise, the throw statement throws an exception. The catch block inside the function sub() collects this exception and again throws the exception using the throw statement. Here, the throw statement is used without any argument. The catch block of the main function catches the re-thrown exception.

19.8   SPECIFYING EXCEPTIONS

The specified exceptions are used when we want to bind the function to throw only specified exceptions. Specific exception is thrown using condition statement and list of data items in throw. The format for such exceptions is as given below:

 

The data type list indicates the type of exception that is permitted to be thrown. If we want to deny a function from throwing an exception, declaring the data type list void as per the following statement can do this.

throw(); // void or vacant list

 

Explanation: In the above program, the check() function is defined. It is followed by an exception specifying statement. The if statements check the value of the formal argument. According to the value, an exception is thrown. In function main(), the function check() is invoked with different values. The output of the program is as given above.

19.9   EXCEPTIONS IN CONSTRUCTORS AND DESTRUCTORS

A copy constructor is called in exception handling when an exception is thrown fro the try block using the throw statement. The copy constructor mechanism is applied to initialize the temporary object. In addition, destructors are also executed to destroy the object. If an exception is thrown from the constructor, destructors are called only for those objects that are completely constructed.

 

Explanation: In the above program, the operators ++ and – are overloaded. The class number() has two constructors and one destructor. The one-argument constructor is used to initialize the data member x with the value given by the user. The overloaded operators are used to increase and decrease the value of the object. When the user specifies the zero value, an exception is thrown from the constructor. The exception is caught by the catch statement. In function() main(), two objects N and N1 are declared. The exception is thrown when the object N1 is created. When the exception is thrown, the control goes catch block. The catch block terminates the program. The destructors are also invoked.

19.10   CONTROLLING UNCAUGHT EXCEPTIONS

C++ has the following functions, and these can be used to control uncaught exceptions.

terminate(): In case the exception handler is not defined when an exception is thrown, in such a case, the terminate() function is invoked. Implicitly, the abort() function is invoked.

 

Explanation: In the above program, an exception is thrown for class two using the statement throw two(). The catch block is defined to handle the exception for class one, and the catch block contains an argument of class one type. When an exception is thrown, it does not find a match; hence, the program is terminated. For termination, the abort() function is called implicitly by the compiler.

set_terminate()

The set terminate() function is used to transfer the control to the specified error-handling function. The set_terminate() function requires only one argument, which is nothing but a function name where control is transferred. It returns nothing. When no function is specified, the program is terminated by an implicit call to abort() function.

 

Explanation: This program is similar to the previous one. The only difference is that in the previous program the compiler does not found a matching catch statement for the exception thrown by the throw statement. The program is terminated. In this program, at the beginning, a user-defined function skip() is defined. The skip() function is associated with the set_terminate() function. When a compiler does not found a matching exception instead of terminating a program, it invokes the function associated with the set_terminate() function. Here, the exception is thrown for an object of class two. The catch statement holds an object of class one. Hence, the thrown exception object does not match the catch object. Due to this mismatch, the function skip() is invoked to handle such an uncertain situation.

19.11   EXCEPTIONS AND OPERATOR OVERLOADING

An exception handling can be sued with operator-overloaded functions. The following program illustrates the same:

 

Explanation: In this program, the operator – is overloaded. When used with class objects, this operator decreases the values of class members. Using the while() loop, the value of the object N is continuously decreased. The object N is initialized with four. The operator – () function checks the value of x (member of object N); if the value of x reaches zero, an exception is thrown, which is caught by the catch statement.

19.12   EXCEPTIONS AND INHERITANCE

In the last few examples, we have learned how the exception mechanism works with the operator function and with constructors and destructors. The following program explains how exception handling can be done with inheritance:

 

Explanation: In the above program, the two classes ABC and abc are declared. The class ABC has two protected data members name and age. The class abc has two float data members’ height and weight with two member functions getdata() and show(). The class abc is derived from class ABC. The statement class abc: public ABC defines the derived class abc. In the function main(), x is an object of the derived class abc. The object x invokes the member function getdata() and show(). This function reads and displays data, respectively. In the function getdata(), the if statement checks the age entered. If the age entered is zero or less than zero, an exception is thrown. The catch block is executed, and the message “Wrong age” is displayed.

19.13   CLASS TEMPLATES WITH EXCEPTION HANDLING

The following program illustrates how excepting handling can be implemented with class templates:

 

Explanation: In the above program, the class square uses the template type of argument. Using conditional operators, the size of the passed argument is checked. If it is equal to one, an exception is thrown; otherwise, the square is calculated and stored in the class data member s. The show() function displays the square on the screen. When character-type data are entered, an exception is thrown, because the size of the character is one and the square cannot be calculated.

19.14   GUIDELINES FOR EXCEPTION HANDLING

1. It is not essential for the throw statement to appear in the try block in order to throw an exception. The throw statement can be placed in any function, if the function is to be invoked through the try block.

    

   	try	Show()
   	{	{
   	statement;	statement;
   	show (variable)	throw (object);
   	statement;	}
   	}
   	catch (object)
   	{
   	statement;
   	}

   Fig. 19.3 throw statement out of try block

   As shown in Figure 19.3, the throw statement is present in the show() function. The show() function is invoked inside the try block. Thus, exception handling can also be defined in the manner described above.

2. When an exception that is not specified is thrown, it is known as an unexpected exception.
3. In case an exception is thrown before the complete execution of a constructor, the destructor for that object will not be executed.
4. As soon as an exception is thrown, the compiler searches nearby handlers (catch blocks). After finding a match, it will be executed.
5. Overuse of exception handling increases the program size. So, apply it whenever most necessary. Incorrect use of exception handling is not consistent and generates bugs in the program. It is hard to debug such bugs.

19.15   MORE PROGRAMS

Explanation: In the above program, an integer array max [5] is declared. The cin statement within the first for loop reads integers through the keyboard. The second for loop and the second if statement within it checks the successive numbers of arrays and stores the largest number in the variable m. Before this, the first if statement checks whether the number is zero. If the number is zero, an exception is thrown.

 

Explanation: In the above program, a character array text [20] is declared. The cin statement accepts the string through the keyboard. The while loop and the statements within it are used to display the string. The if statement checks every character of the string to see whether it is a null character or other character. If it is a null character, an exception is thrown; otherwise, the character is displayed on the screen. Thus, at last when a null character is found, an exception is thrown. The message “End of string” is displayed by the catch block.

1. A few languages support the exception-handling feature. Without this feature, the programmer needs to detect bugs on their own.
2. The errors may be logical errors or syntactic mistakes (syntax mistakes). The logical error remains in the program due to an unsatisfactory understanding of the program. The syntax mistakes are due to a lack of understanding of the programming language itself.
3. ANSI C++ is built in language functions for trapping errors and controlling exceptions. All C++ compilers support this newly added facility.
4. C++ provides a type-secure, integrated procedure for coping with the predictable but peculiar conditions that arise in run time.
5. The goal of exception handling is to create a routine that detects and sends an exceptional condition in order to execute suitable actions.
6. An exception is an object. It is sent from the part of the program where an error occurs to the part of the program that is going to control the error.
7. C++ exception method provides three keywords; they are try, throw, and catch. The keyword try is used at the starting of exception. The entire exception statements are enclosed in curly braces. It is known as try block.
8. The catch block receives the exception sent by the throw block in the try block.
9. We can also define multiple catch blocks; in the try block, such programs also contains multiple throw statements based on certain conditions.
10. It is also possible to define a single or default catch block from one or more exceptions of different types. In such a situation, a single catch block is used for catching exceptions thrown by the multiple throw statements.
11. It is also possible to again pass the exception received to another exception handler; that is, an exception is thrown from the catch block; this is known as a re-throwing exception.
12. The specified exceptions are used when we want to bind the function to throw only the specified exception. Specific exception is thrown using condition statement and list of data items in throw.

 

(A) Answer the following questions

1. What do you mean by exception handling?
2. How many different types of errors are encountered in the program?
3. Describe the role of keywords try, catch, and throw in exception handling.
4. What will happen if the programming language does not support the exception-handling feature?
5. What do you mean by re-throwing of an exception?
6. Explain specifying exception with necessary steps.
7. How are multiple catch blocks defined?
8. What will happen if an exception is thrown for which no matching catch block is defined?
9. Explain guidelines for exception handling.
10. Explain the mechanism of exception handling.
11. Explain the use of function set_terminate(). How can we associate a function with this statement?

(B) Answer the following by selecting the appropriate option

1. The statement catches the exception
   • catch
   • try
   • throw
   • template
2. In the multiple catch statement, the number of the throw statement is
   • same as the catch statement
   • twice the catch statement
   • only one throw statement
   • none of the above
3. Exception is generated in
   • try block
   • catch block
   • throw block
   • none of the above
4. In exception handling, one of the following functions is implicitly invoked:
   • abort()
   • exit()
   • assert()
   • none of the above
5. What will happen if the throw() function has an empty exception and you place it after a function argument list?
   • No exception will be thrown
   • Default exception will be invoked
   • The nearest one exception is thrown
   • Unexpected actions by the program
6. If the catch statement is defined to catch an exception for the base class type object, it can also catch all_________-derived classes of the base class.
   • errors
   • parameters
   • exceptions for objects
   • none of the above

(c) Attempt the following programs

1. Write a program to accept 10 integers in an array. Check all numbers in the array. When any negative number is found, throw an exception.
2. Write a program to accept a string. When any space is encountered, throw an exception.
3. Write a program to explain the concept of multiple catch statements.
4. Write a program to use the catch statement.
5. Write a program to call a nested function. The function has an exception. Include essential exception-handling statements.