Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/cpp/cpp-exception-handling-interview-questions-and-answers/ below:

Top C++ Exception Handling Interview Questions and Answers

Last Updated : 06 Nov, 2024

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 interview preparation article, we will learn about the top 15 most frequently and most asked interview questions on Exception Handling.

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.

Synchronous exceptions are the exceptions that occur at a particular instruction. They can only originate 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.

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.

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.

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
}

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".

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().

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

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

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

Java

C++

#include <iostream>
using namespace std;

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

Explanation: An integer value 10 is thrown as an exception. It can't be interpreted as char * means we need to go with default catch that is why the "Default Exception" is printed.

#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 

Explanation: When a throw statement is encountered, the program control skips all the remaining statements of that block and goes directly to the corresponding catch block. That is why "After Error" is not printed.

#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;
}

Output:

Caught Base Exception

Explanation: If both base and derived classes are caught as exceptions, then the catch block of the derived class must appear before the base class because if we put the base class first then the derived class catch block will never be reached. For example, the following C++ code prints “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;
}

Output:

An error will be raised

Explanation: The default catch block should be the last catch block or else other catch blocks will never be reached.

#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

Explanation: "Inner Catch" is called followed by "Outer Catch" because of rethrowing exceptions.

• Violation of syntactic and semantic rules of a language
• Missing Semicolons
• Missing double quotes
• Violation of program interface

Answer: Violation of syntactic and semantic rules of a languages

• Continue running
• Termination of the program
• Calls other functions of the program
• Removes the exception and tells the programmer about an exception

Answer: Termination of the program

• A number divided by zero
• Semicolon not written
• Variable not declared
• Wrong written expression

Answer: A Number divided by zero

• stop()
• aborted()
• terminate()
• abandon()

Answer: terminate()

• True
• False

Answer: False

#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;
}

• This is exception
• Syntax error
• No output
• The program crashed at runtime 

Answer: The program crashed at runtime

#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

• This is an exception
• Syntax error
• No output
• The program crashed at runtime

Answer: This is an exception

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4