Exception Handling : MCQs & PYQs with Explanation

Option B

The function Xhandler(int test) checks if test is non-zero. If test is non-zero, it throws test as an exception. The catch (int i) block catches the integer exception and prints "Hello# : " followed by the value of i. If test is zero, no exception is thrown, so nothing is printed.
In main():

• Xhandler(1); throws 1 : Prints "Hello# : 1"
• Xhandler(0); no throw : Prints Nothing
• Xhandler(3); throws 3 : Prints "Hello# : 3"
• Xhandler(2); throws 2 : Prints "Hello# : 2"

Option A

In exception handling, when an exception is thrown, the system searches for a matching catch block to handle it. The matching is based on the type of the exception.
If no matching catch block is found, the exception remains unhandled, and the program cannot continue normal execution. In such cases, the program terminates abnormally.

Option C

Any unwanted or unexpected event that disturbs the normal flow of the program is called exception.

• An exception is a problem that arises during the execution of a program.
• Exceptions are runtime error which a programmer usually does not expect.
• The keyword try, catch and throw are used in exception handling mechanism.

Any code that might cause an error or abnormal program termination should be placed inside a try block. The try block allows the program to monitor risky statements. 
If an exception occurs, control is immediately transferred to the matching catch block. The throw keyword is only used to signal an exception.

Option B

In C++, exceptions are abnormal conditions that occur during program execution. Exceptions are generally classified into two types:

• Synchronous Exceptions.
• Asynchronous Exceptions.

A synchronous exception occurs due to the execution of a particular instruction in the program. These exceptions are directly related to program logic or operations.
Examples:

• Divide by zero.
• Array index out of range.
• Overflow.

Therefore, “Out-of-range-index” is a synchronous exception because it occurs during program execution due to invalid indexing.
An asynchronous exception occurs due to external events that are not directly caused by the current program instruction.
Examples:

• Keyboard interrupts.
• Hardware failure.
• Power failure.

Therefore, keyboard interrupts are asynchronous exceptions.

Option A

(i) There can be try block without catch block but vice versa is not possible.

• In Java, a try block must always be followed by either a catch block or a finally block. But you cannot have a catch block without a try. So, this statement is true.

(ii) There is no limit on the number of catch blocks corresponding to a try block.

• In Java, you can write multiple catch blocks after a single try block to handle different types of exceptions. There is no restriction on the number of catch blocks. So, this statement is true.

(iii) The object must be created of a specific class of which the error has occurred otherwise runtime error will occur.

• In Java, when an exception occurs, the JVM automatically creates an exception object of the corresponding class and throws it. You do not need to manually create the object. So, this statement is false.

(iv) To execute a code with each and every run of program, the code is written in finally block.

• The finally block in Java is always executed, whether an exception is thrown or not. It is generally used for cleanup code like closing files, releasing resources, etc. So, this statement is true.

public class ExceptionExample {
    public static void main(String[] args) {
        try 
        {
            int a = 10;
            int b = 0;
            int c = a / b;
            System.out.println("Result: " + c);
        } 
        catch (ArithmeticException e) 
        {
            System.out.println("Error: Cannot divide by zero!");
        } 
        catch (NullPointerException e) 
        {
            System.out.println("Error: Null value encountered!");
        } 
        finally 
        {
            System.out.println("Finally block: This will always execute.");
        }
        System.out.println("Program continues after exception handling.");
    }
}

Option A

In C++, exception handling allows a program to catch and respond to errors using try and catch blocks. When an exception is thrown, the program searches for a matching catch block that can handle that particular type of exception. 
C++ also allows try and catch blocks to be nested inside one another, meaning one try block can be placed entirely within another try block.
Inside a catch block, the keyword throw; used all by itself, without specifying any value after it, is called a rethrow. This special statement takes whatever exception was just caught and throws it again, sending it further outward to be caught by another surrounding catch block, if one exists.
The catch block written as catch with three dots inside the parentheses, i.e, catch(…) is called a catch all handler. This special catch block is designed to catch absolutely any type of exception.

#include <iostream>
using namespace std;
int main()
{
    try
    {
        try
        {
            cout << "Exception is Thrown" << endl;
            throw 5;
        }
        catch(int)
        {
            cout << "A";
            throw; // Rethrow the same exception
        }
    }
    catch(...)
    {
        cout << "B";
    }
    return 0;
}
OUTPUT
Exception is Thrown
AB

Option B

In C++ exception handling, the try block contains the code that may generate (throw) an exception.
Any statement inside the try block that causes an error can throw an exception. The actual handling of the exception is done in the catch block.

• The try block, where an exception is generated.
• The catch block, where an exception is caught and handled.

Option D

In C++, a constructor is responsible for initializing an object. If the constructor throws an exception before the object has been completely constructed, the object is considered not fully constructed. Therefore, its destructor is not called for the object itself.
However, an important point is that already-constructed member objects and base-class objects are properly destroyed when the constructor fails. This ensures that resources acquired by those fully constructed sub objects are released.

Programming Example : 1

#include <iostream>
using namespace std;
class Demo
{
public:
    Demo()
    {
        cout << "Constructor Called" << endl;
        throw 10;
        cout << "Constructor completed" << endl;
    }
    ~Demo()
    {
        cout << "Destructor Called" << endl;
    }
};
int main()
{
    try
    {
        Demo obj;
    }
    catch(int)
    {
        cout << "Exception Caught" << endl;
    }
    return 0;
}
OUTPUT
Constructor Called
Exception Caught

Programming Example : 2

#include <iostream>
using namespace std;
class Base
{
public:
    Base()
    {
        cout << "Base Constructor Called"<<endl;
    }
    ~Base()
    {
        cout << "Base Destructor Called"<<endl;
    }
};
class Derived : public Base
{
public:
    Derived()
    {
        cout << "Derived Constructor Called"<<endl;
        throw 10;
        cout << "Derived Constructor Completed"<<endl;
    }
    ~Derived()
    {
        cout << "Derived Destructor Called"<<endl;
    }
};
int main()
{
    try
    {
        Derived obj;
    }
    catch(int)
    {
        cout<<"Exception Caught"<<endl;
    }
    return 0;
}
OUTPUT
Base Constructor Called
Derived Constructor Called
Base Destructor Called
Exception Caught