250+ TOP MCQs on Catching Exceptions and Answers

By engineer / May 26, 2024

This section on C++ programming interview questions and answers on “Catching Exceptions”. One shall practice these interview questions to improve their C++ programming skills needed for various interviews (campus interviews, walkin interviews, company interviews), placements, entrance exams and other competitive exams. These questions can be attempted by anyone focusing on learning C++ programming language. They can be a beginner, fresher, engineering graduate or an experienced IT professional. Our C++ programming interview questions come with detailed explanation of the answers which helps in better understanding of C++ concepts.

Here is a listing of C++ programming interview questions on “Catching Exceptions” along with answers, explanations and/or solutions:

1. How many parameters does the throw expression can have?
a) 1
b) 2
c) 3
d) 4
Answer: a
Clarification: In c++ program, We can be able to throw only one error at a time.

2. Where exception are handled?
a) inside the program
b) outside the regular code
c) both inside or outside
d) main program
Answer: b
Clarification: Exception are handled outside the regular code.

3. Which is used to check the error in the block?
a) try
b) throw
c) catch
d) handler
Answer: a
Clarification: The try block is used to check for errors, if there is any error means, it can throw it to catch block.

4. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    class myexception: public exception
```
```
    {
```

        virtual const char* what() const throw()

```
        {
```
```
            return "exception arised";
```
```
        }
```
```
    } myex;
```
```
    int main () 
```
```
    {
```
```
        try
```
```
        {
```
```
            throw myex;
```
```
        }
```
```
        catch (exception& e)
```
```
        {
```
```
            cout << e.what() << endl;
```
```
        }
```
```
        return 0;
```
```
    }
```

a) exception arised
b) error
c) exception
d) runtime error
Answer: a
Clarification: In this program, We are arising a standard exception and catching that and returning a statement.
Output:

$ g++ goe.cpp
$ a.out
exception arised

5. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    int main()
```
```
    {
```
```
        int age=5;
```
```
        try 
```
```
        {
```
```
            if (age < 0)
```

                throw "Positive Number Required";

```
            cout  << age << "nn";
```
```
        }
```
```
        catch(const char* Message)
```
```
        {
```

            cout << "Error: " << Message;

```
        }
```
```
        return 0;
```
```
    }
```

a) 5
b) 10
c) 15
d) Positive Number Required
Answer: a
Clarification: In this program, We are checking the age of a person, If it is zero means, We will arise a exception.
Output:

6. What will be the output of the following C++ code?

```
    #include 
```
```
    using namespace std;
```
```
    double division(int a, int b)
```
```
    {
```
```
        if ( b == 0 )
```
```
        {
```

            throw "Division by zero condition!";

```
        }
```
```
        return (a / b);
```
```
    }
```
```
    int main ()
```
```
    {
```
```
        int x = 50;
```
```
        int y = 0;
```
```
        double z = 0;
```
```
        try 
```
```
        {
```
```
            z = division(x, y);
```
```
            cout << z << endl;
```
```
        }
```
```
        catch (const char* msg) 
```
```
        {
```
```
            cout << msg << endl;
```
```
        }
```
```
        return 0;
```
```
    }
```

a) 50
b) 0
c) Division by zero condition!
d) 100
Answer: c
Clarification: We are dividing the values and if one of the values is zero means, We are arising an exception.
Output:

$ g++ goe2.cpp
$ a.out
Division by zero condition!

7. What will be the output of the following C++ code?

```
    #include 
```
```
    #include 
```
```
    using namespace std;
```
```
    int main()
```
```
    {
```
```
        double Op1 = 10, Op2 = 5, Res;
```
```
        char Op;
```
```
        try 
```
```
        {   
```

            if (Op != '+' && Op != '-' && Op != '*' && Op != '/')

```
                throw Op;
```
```
            switch(Op)
```
```
            {
```
```
            case '+':
```
```
                Res = Op1 + Op2;
```
```
                break;
```
```
            case '-':
```
```
                Res = Op1 - Op2;
```
```
                break;
```
```
            case '*':
```
```
                Res = Op1 * Op2;
```
```
                break;
```
```
            case '/':
```
```
                Res = Op1 / Op2;
```
```
                break;
```
```
             }
```

             cout << "n" << Op1 << " " << Op << " "<< Op2 << " = " << Res;

```
         }
```
```
         catch (const char n)
```
```
         {
```

             cout << n << " is not a valid operator";

```
         }
```
```
         return 0;
```
```
    }
```

a) 15
b) 5
c) 2
d) is not a valid operator
Answer: d
Clarification: It will arise a exception because we missed a operator.
Output:

$ g++ goe3.cpp
$ a.out
is not a valid operator

250+ TOP MCQs on Catching Exceptions and Answers

Leave a Comment Cancel Reply

Interview Questions List

Related Posts

Leave a Comment Cancel Reply