C++ Exception Handling

An extensive program or software rarely works the first time correctly. There may be errors in this. This tutorial will teach you how to handle exceptions in C++. The two most common types of errors are:

• Logical errors
• Syntactic errors

Programmers can debug these errors by exhausting debugging and testing procedures. But programmers often encounter peculiar problems apart from logic or syntax errors. These types of errors are known as exceptions. Exceptions are runtime anomalies or unusual logical conditions that may come up while executing the C ++ program. In this chapter, you will learn about these anomalies and how to handle these anomalies within a C++ program.

What Is Exception Handling?

Exceptions allow a method to react to exceptional circumstances and errors (like runtime errors) within programs by transferring control to special functions called handlers. For catching exceptions, a portion of code is placed under exception inspection. Exception handling was not a part of the original C++. It is a new feature that ANSI C++ included in it. Now almost all C++ compilers support this feature. The exception handling technique offers a securely integrated approach to avoid the unusual predictable problems that arise while executing a program. There are two types of exceptions:

1. Synchronous exceptions
2. Asynchronous exceptions

Errors such as out of range index and overflow fall under synchronous type exceptions. Those errors caused by events beyond the program's control are called asynchronous exceptions. The main motive of the exceptional handling concept is to provide a means to detect and report an exception so that appropriate action can be taken. This mechanism needs a separate error handling code that performs the following tasks:

• Find and hit the problem (exception)
• Inform that the error has occurred (throw exception)
• Receive the error information (Catch the exception)
• Take corrective actions (handle exception)

The error handling mechanism consists of two parts. These are:

1. To detect errors
2. To throw exceptions and then take appropriate actions

Exception handling in C++ is built on three keywords: try, catch, and throw.

• try
• throw: When a problem is detected, a program throws an exception, which is done using the "throw" keyword.
• catch: A program catches an exception with an exception handler where programmers want to handle the anomaly. The keyword catch is used for catching exceptions.

The Catch blocks catching exceptions must immediately follow the try block that throws an exception. The general form of these two blocks is as follows:

Syntax:

try
{
    throw exception;
}

catch(type arg)
{
    //some code
}

If the try block throws an exception, then program control leaves the block and enters into the catch statement of the catch block. If the type of object thrown matches the argument type in the catch statement, the catch block is executed for handling the exception. Divided-by-zero is a common exception that generally occurs in arithmetic-based programs.

A Simple Program for Exception Handling in C++

Example:

#include<iostream>
using namespace std;

int main()
{
    try {
        throw 6;
    }

    catch (int a) {
        cout << "An exception occurred!" << endl;
        cout << "The exception number is: " << a << endl;
    }
}

Output:

An exception occurred!
The exception number is: 6

The following example shows the handling of division by zero exception.

Example:

#include<iostream>
using namespace std;

double division(int var1, int var2)
{
    if (var2 == 0) {
        throw "Division by Zero.";
    }
    return (var1 / var2);
}

int main()
{
    int a = 30;
    int b = 0;
    double d = 0;

    try {
        d = division(a, b);
        cout << d << endl;
    }
    catch (const char* error) {
        cout << error << endl;
    }

    return 0;
}

Output:

Division by zero.

Advantages of Exception Handling

1. Programmers can deal with them at some level within the program
2. If an error can't be dealt with at one level, it will automatically be shown at the next level, where it can be dealt with.