Exception Handling is one of the most important topics from the C++ Interview perspective. Exception handling is an effective means to handle the runtime errors that disrupt the normal flow of the program. It is one of the most used concepts in real-world embedded systems so it is common to encounter questions based on exception handling during interviews.

In this article, we will learn about the top 15 most frequently and most asked interview questions on Exception Handling.

Exception Handling Interview Questions and Answers

1. What is an Exception?

Conditions responsible for creating errors during the execution of a program are known as Exceptions. These errors can interrupt the execution of the program and if the program can’t handle these exceptions then OS handles them and the program is terminated abruptly.

2. Explain Synchronous Exceptions and Asynchronous Exceptions?

Synchronous exceptions are the exceptions that occur at a particular instruction. They can only be originated from throw expressions and are caused due to errors like incorrect input or array out-of-index access in a program.
Asynchronous exceptions are the exceptions that create errors that are not controllable by the program. For example-hardware malfunctions, disk failure, etc.

3. What is Exception Handling?

Conditions responsible for creating errors during the execution of a program are known as Exceptions. Handling these exceptions by either removing these conditions or by using some other operations than normal operations is known as exception handling.  Exception handling is an effective means to handle the runtime errors that disrupt the normal flow of the program.

4. Why do we need exception Handling?

We use Exception Handling for the following reasons:

1. Separate Error code from Normal code to help us understand errors easily.
2. Functions/Methods can be handled only by the exceptions they choose. The exceptions not chosen will be handled by the caller.
3. Exceptional handling allows the grouping of error types which helps in categorizing them.
4. It makes the program’s error type easy to understand.

5. How to implement exception handling in C++?

C++ supports exception handling. It is implemented by try{ } and catch( ){ } statements.

• The try statement allows you to define a block of code to be tested for errors while it is being executed.
• The throw keyword throws an exception when a problem is detected, which lets us create a custom error.
• The catch statement allows you to define a block of code to be executed if an error occurs in the try block.

It follows certain rules:

• The catch can be executed in multiple ways according to the argument thrown by the try.
• There can be multiple catch( ) but only a single try.
• If try throws but catch is not able to catch it then terminate() will be called by default.
• If no argument is executed it will just continue to the statement after the catch block.

Example:

try{
    throw 10;  //catch(int x)
    throw "x"; //catch(...)
}
catch(int x){
    //int catch
}
catch(...){
    //default catch
}

6.  What is the use of terminate( ) in C++?

The terminate( ) function is used to abort the program by default rather than throwing it for a catch. The terminate( ) function can be used for the exceptions which can’t be handled instead we just abort them. The terminate() functions calls the terminate_handler which by default calls the abort() function. For example:

if(x==0){
    terminate();
}

In this program, if x==0, it will automatically end the file with a note saying “terminate called without an active exception”.

7. What is the use of unexpected( ) in C++?

The unexpected() function is called when the exception thrown by a function is a type not listed in the exception specification for the function. The unexpected( ) will call the unexpected_handler that by default calls the terminate().

8. What will happen if an exception is thrown but not caught anywhere?

When an exception is thrown but not caught anywhere, the program will terminate abnormally.

9. Explain the concept of Rethrowing exceptions?

A rethrowing exception is a term used when we throw the exception again from one catch block to another. The exception is thrown towards another outside catch block.

Example:

#include <iostream>
using namespace std;

void help()
{
    try {
        throw 10;
    }
    catch (...) {
        cout << "First throw called\n";
        throw;
    }
}

int main()
{

    try {
        help();
    }
    catch (...) {
        cout << "Rethrowing throw called\n";
    }

    return 0;
}

First throw called
Rethrowing throw called

10. What is the difference between exception handling in C++ and Java?

The following table list the differences between exception handling in C++ and Java:

#include <iostream>
using namespace std;

int main()
{
    try {
        throw 10;
    }
    catch (char* excp) {
        cout << "Caught " << excp;
    }
    catch (...) {
        cout << "Default Exception\n";
    }
    return 0;
}

Default Exception

#include <iostream>
using namespace std;
int main()
{
    int x = -10;
    try {
        cout << "Before Error\n";
        if (x < 0) {
            throw x;
            cout << "After Error\n";
        }
    }
    catch (int x) {
        cout << "Exception Caught \n";
    }

    cout << "After catch \n";
    return 0;
}

Before Error
Exception Caught 
After catch 

#include<iostream>
using namespace std;
 
class Base {};
class Derived: public Base {};
int main()
{
   Derived d;
   try {
       throw d;
   }
   catch(Base b) {
        cout<<"Caught Base Exception";
   }
   catch(Derived d) {
        cout<<"Caught Derived Exception";
   }
   return 0;
}

Caught Base Exception

#include <iostream>
using namespace std;

int main()
{
    try {
        throw 10;
    }
    catch (...) {
        cout << "default exception \n";
    }
    catch (int param) {
        cout << "integer exception \n";
    }

    return 0;
}

An error will be raised

#include <iostream>
using namespace std;

int main()
{
    try {
        try {
            throw 10;
        }
        catch (int n) {
            cout << "Inner Catch\n";
            throw;
        }
    }
    catch (int x) {
        cout << "Outer Catch\n";
    }
    return 0;
}

Inner Catch
Outer Catch

#include <iostream>
using namespace std;

int main()
{
    try {
        int x = 1;
        int y = 0;
        int ans;

        ans = x / y;
    }
    catch (exception E) {
        cout << "This is exception" << endl;
    }
    return 0;
}

#include <iostream>
using namespace std;
int main()
{
    try {
        int x = 1;
        int y = 0;
        int ans;

        if (y == 0)
            throw "divide by zero";
        ans = x / y;
    }
    catch (char const* e) {
        cout << "This is exception " << e << endl;
    }
    return 0;
}

// This code is modified by Susobhan Akhuli