Exception Handling

So far, we have seen that a program is a series of instructions given to the computer to perform specific assignments. These instructions are primarily giver to the compiler to analyze and transmit them further. If the compiler can accurately understand an instruction, it produces a result. If it can't understand it, it may produce an error or just a bad or unreliable result. Once your instructions are clear and understandable, the program may display requests to the user such as expecting a value typed using the keyboard. This means that, even if your primary instructions are correct, a problem may come from an action performed by the user or an external force. Therefore, besides writing code, you also should be able to predict bad actions or behavior that could be performed on your program(s).

An exception is an abnormal behavior that could happen to your program. The ability to take care of such a behavior is called exception handling. If you write good instructions in your program and execute it, when a bad value is provided and the program behaves abnormally, the program is said to raise an exception.

The Microsoft implementation of the C language introduced the issue of abnormal behaviors through the Structured Exception Handling (SEH); this is fully supported in (Microsoft) C++ and subsequently in Managed C++. C allows you to create an object on the heap and make sure it is destroyed or gotten rid of. To support this, you first create a section of code that starts with either the try or the __try keywords (Microsoft C++ supports both). The body of this try or __try section must start with an opening curly bracket "{" and must end with a closing curly bracket "}". In this section, known as the body of the try sor __try ection, you can allocate memory and possibly perform any normal assignment that is necessary. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"
#include ".\school.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    CSchool __gc *school;
	
    try {
	school = __gc new CSchool;

	*school->SchoolCapacity = 6248;
		
	Console::Write(S"\nScholl Capacity: ");
	Console::WriteLine(*school->SchoolCapacity);
	Console::WriteLine();
    }
	
    return 0;
}

If you decide to use a try or __try section to allocate memory for an object, you must (normally can) provide a way to destroy the object in a subsequent section. This other section, which must come after the try or __try section, starts with the __finally keyword and has its own body always delimited with curly brackets. Although you can use either try or __try, only the __finally and not the finally is used. In the body the __finally section, you can delete a variable or call a method that closes it. Here is an example

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"
#include ".\school.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    CSchool __gc *school;
	
    try {
	school = __gc new CSchool;

	*school->SchoolCapacity = 6248;
		
	Console::Write(S"\nScholl Capacity: ");
	Console::WriteLine(*school->SchoolCapacity);
	Console::WriteLine();
    }
    __finally
    {
	Console::WriteLine(" - Called __finally, always\n");
	delete school;
    }
	
    return 0;
}

This would produce:

The CSchool principal is in the house

Scholl Capacity: 6248

 - Called __finally, always

The CSchool principal is leaving the building

Press any key to continue

As you can see, the __finally section always executes. It's role in this case is to destroy the object.

Although you can omit a __finally section in your program, whenever you create a try section, it must be followed by some exception handling-related section. We will review other possible sections. Just remember that a try section cannot be used alone.

The C++ language provides its own support of exception handling. C++ provides three keywords to handle an exception.

1. Trying the normal flow: To deal with the expected behavior of a program, use the try or __try keyword as in the following syntax:
   
   try {Behavior}
   
   The try or __try keyword is required. It lets the compiler know that you are attempting a normal flow of your program. The actual behavior that needs to be evaluated is included between an opening curly bracket “{“ and a closing curly bracket “}”. Inside of the brackets, implement the normal flow that the program should follow, at least for this section of the code.
2. Catching Errors: During the flow of the program as part of the try section, if an abnormal behavior occurs, instead of letting the program crash or instead of letting the compiler send the error to the operating system, you can transfer the flow of the program to another section that can deal with it. The syntax used by this section is:
   
   catch(Argument) {WhatToDo}

   This section always follows the try section and there must not be any code between the try’s closing bracket and the catch section. This means that, if you are using a __finally section, it must not be included before a catch section. The catch keyword is required and follows the try section.
   
   The catch behaves a little like a function. It uses an argument that may be passed by the previous try section. The argument can be a regular variable or a class. If there is no argument to pass, the catch must at least take a three-period argument as in catch(…). The behavior of the catch clause starts with an opening curly bracket “{“ and ends with a closing curly bracket “}”. The inside of the brackets is called the body of the catch clause. Therefore, use the body of the catch to deal with the error that was caused.
   
   Combined with the try or __try block, the syntax of an exception would be:
    

   try { // Try the program flow } catch(Argument) { // Catch the exception }

3. Throwing an error: There are two main ways an abnormal program behavior is transferred from the try block to the catch clause. This transfer is actually carried by the throw keyword. Unlike the try and catch blocks, the throw keyword is independent of a formal syntax but still follows some rules. For example, it is usually included in a try or __try section.

As mentioned above, you can create a program that takes exception handling into account as follows:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    Console::Write(S"Enter Student Age: ");
    String *strAge = Console::ReadLine();

    studentAge = Int32::Parse(strAge);

    try {
        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(...)
    {
    }

    Console::WriteLine();
    return 0;
}

If you run this program and type a positive or negative integer for the student’s age, the program would respond by displaying the number typed. If you run the program and type a letter or a group of characters and press Enter, the program would crash and display a debugging window:

You can then click No to continue.

When your program encounters an exception, there are various ways you can deal with it, you can generate a message and display it to the user, you can define one or more functions to address the exceptions of your program, you can create a central class that manages the exceptions of your program, or you can use the exception classes already available with your programming environment. Rather than spending time creating exceptions from scratch, we will take advantage of the Microsoft .NET Framework's built-in mechanisms of handling exceptions.

Managed C++ adds its own flavor or improvement to existing C and C++' exception handling through a vast group of classes. The Microsoft .NET Framework, the main library that Managed C++ uses, features a general class called Exception and defined in the System namespace. Besides supporting Structured Exception Handling (SEH) and C++ exceptions, the System::Exception class provides a main and particular exceptions for various classes of the library, especially those in which a particular action can be taken. Based on this, Managed C++ deals with exceptions in a general concept referred to as Managed Exceptions.

A managed exception is an exception that is dealt with in a managed class. To make Managed C++ an effective language, you can write a normal program and let the compiler deal with exceptions as long as you create appropriate try and catch sections in your program. 

When an exception is thrown, you should present a message to the user to indicate that something bad happened and possibly suggest what the user should do. The Exception class provides messages for various circumstances in a managed application. To use one of these messages, you can pass a pointer to Exception in a catch clause and then access the Message property in the body of the catch section. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;
	
int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        String *strAge = Console::ReadLine();
        studentAge = Int32::Parse(strAge);

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(Exception *exc)
    {
	Console::WriteLine(exc->Message);
    }

    Console::WriteLine();
    return 0;
}

When you execute this program, if you provide a character or a group of characters, the program would not crash but would display a message from the Exception class:

Enter Student Age: Allo!
Input string was not in a correct format.

Press any key to continue

When an exception occurs, the compiler looks for how you decided to handle it. In the above example, the compiler simply finds out that something unusual happened. In this case, a char type was provided as a value for an Int32 type. In this case, and as described already, the compiler would get out of the try section and look for a catch section. Since we provided one that takes an Exception as argument, and it was the only catch section provided, the compiler would use it and end that part of the program. C++ provides better ways of creating, managing or customizing the message(s) displayed to the user.

Before specifying how to deal with your own exception, you can start by stating what exception you want to deal with. This is done by creating an if conditional statement followed by a throw keyword. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        studentAge = Int32::Parse(Console::ReadLine());

        if( studentAge < 0 )
            throw;

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(Exception *exc)
    {
	    Console::WriteLine(exc->Message);
    }

    Console::WriteLine(S"");
	return 0;
}

When you use the throw keyword, the compiler proceeds in a top-down approach to analyze the program:

1. If the compiler encounters a try block, it processes it 
2. If no exception occurs in the try block, the rest of the try block is executed
   If an exception occurs in the try block, the compiler checks if there is a throw keyword in the current try section:
   1. If there is no throw section, the compiler gets out of the try section and looks for a catch section that can carry the message
   2. If there is a throw keyword by itself, the compiler gets out of the try section  and looks for a catch section. The catch section in this case only allows the compiler to display a message because there must be at least one catch section

In the above example, we typed a simple throw keyword. If the user provides a negative number to the request, a message would be displayed. Here is an example:

Enter Student Age: -25
External component has thrown an exception.

Press any key to continue

Instead of an empty throw keyword, you can specify the message you want to display to the user. To do this, you can type a string to the right side of throw. Then, create a catch clause that takes a string as argument and displays that message in its section. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        studentAge = Int32::Parse(Console::ReadLine());

        if( studentAge < 0 )
            throw S"Negative numbers are not allowed";

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(String* msg)
    {	
	Console::WriteLine(msg);
    }

    Console::WriteLine(S"");
    return 0;
}

This time, if the exception that occurs is conform to the conditional statement preceding the throw keyword, your message would display:

Enter Student Age: -21
Negative numbers are not allowed

Press any key to continue

In the example above, we mostly assumed only one type of exception because we were only concerned with the user typing a negative value as a person's age. As you may suspect, there can be various types of problems that occur during the lifetime of a program. For example, if you write a program that expects a positive number, a user may type a character, a string, or a negative value. In this case, you can prepare your program to deal with these different types of exceptions in the same program.

To deal with different exceptions in your program, you can create various catch clauses. The formula to use is

try {
	Code to Try
}
catch(Arg1)
{
	One Exception
}
catch(Arg2)
{
	Another Exception
}

Once again, the compiler would follow a top-down approach. The compiler enters the try section and starts executing the code inside the try section:

• If an exception occurs, the compiler looks for a throw keyword:
  1. If there is no throw clause, the compiler gets out of the try section and proceeds as we saw earlier
  2. If there is a throw clause, the compiler examines the value on the right side of throw. This value can be a number, a character, or a string. Therefore, the compiler notes the type of value on the right side of throw and gets out of the try section

     After getting out of try, the compiler considers the argument of the first catch clause it finds

     1. If the argument matches the value of the throw section, then that catch clause is executed and the compiler considers that the exception has been dealt with
     2. If the argument of the first catch clause doesn't match the value of the throw section, then the compiler skips that catch clause and considers the next catch clause. The compiler continues examining the catch clauses that you provided
     3. If an argument of one of the catch clauses matches the thrown error, its body executes. If no catch matches the thrown error, you have (or the compiler has) two alternatives. If there is no catch that matches the error (which means that you didn’t provide a matching catch), the compiler hands the program flow to the operating system (which may call the terminate() function). Another alternative is to include a catch clause whose argument is three periods: catch(…). The catch(…) is used if no other catch, provided there was another, matches the thrown error. The catch(…), if included as part of a catch clause, must always be the last catch, unless it is the only catch of the clause.

Based on this, you can create as many catch clauses as necessary after a try block to dealt with different types of errors. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        studentAge = Int32::Parse(Console::ReadLine());

            if( studentAge <= 10 )
		throw S"Children 10 or younger are not allowed in this club";
            if( studentAge >= 21 )
		throw 0;

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(String* msg)
    {	
	Console::WriteLine(msg);
    }
    catch(const int n)
    {
	Console::WriteLine(S"Only young adults, less than 21, are considered in this program");
    }
    catch(...)
    {
	Console::WriteLine(S"There was a problem with the value you provided");
    }

    Console::WriteLine(S"");
    return 0;
}

If the user provides a normal value, this program would behave as expected:

Enter Student Age: 15

Student Age: 15

Press any key to continue

One test of this program would produce:

Enter Student Age: 6
Children 10 or younger are not allowed in this club

Press any key to continue

Here is another test of the program:

Enter Student Age: 24
Only young adults, less than 21, are considered in this program

Press any key to continue

Another test of the program would produce:

Enter Student Age: Hello
There was a problem with the value you provided

Press any key to continue

As mentioned already, the Exception class provides a Message property used to display a message to the user about an error. Instead of, or as opposed to, creating a normal string after the throw keyword, you can create and pass your message to the Exception class. To create your own message, in the section where you anticipate the exception, type the throw keyword followed by the new keyword and call one of the constructors of the Exception class you want or need to call. The parent class itself offers four constructors, one of which takes as argument a String. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;


int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        studentAge = Int32::Parse(Console::ReadLine());

            if( studentAge <= 10 )
		throw new Exception(S"Children 10 or younger are not allowed in this club");
            if( studentAge >= 21 )
		throw 0;

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(Exception *e)
    {	
	Console::WriteLine(e->Message);
    }
    catch(const int)
    {
	Console::WriteLine(S"Only young adults, less than 21, are considered in this program");
    }
    catch(...)
    {
	Console::WriteLine(S"There was a problem with the value you provided");
    }

    Console::WriteLine(S"");
    return 0;
}

In the above example, we considered two cases of numbers, less than 11 and greater than 20. These two exceptions are based on a numeric value. Instead of writing different catch clauses to deal with these exceptions, you can write a single catch clause that takes a numeric value as argument. Then, in the body of the catch, you can consider each possibility and act accordingly. Here is an example:

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

int _tmain()
{
    // TODO: Please replace the sample code below with your own.
    int studentAge;

    try {
        Console::Write(S"Enter Student Age: ");
        studentAge = Int32::Parse(Console::ReadLine());

        if( studentAge <= 10 )
            throw 1;
        if( studentAge >= 21 )
	   throw 2;

        Console::WriteLine(S"\nStudent Age: {0}", __box(studentAge));
    }
    catch(const int n)
    {	
	if( n == 1 )
	    Console::WriteLine(S"Children 10 or younger are not allowed in this club");
	if( n == 2 )
	    Console::WriteLine(S"Only young adults, less than 21, are considered in this program");
    }
    catch(...)
    {
	Console::WriteLine(S"There was a problem with the value you provided");
    }

    Console::WriteLine(S"");
    return 0;
}