Cpp Programming Questions Answers - Uncaught Exceptions

This section on C++ programming questions and answers focuses on “Uncaught Exceptions”. One shall practice these questions to improve their C++ programming skills needed for various interviews (campus interviews, walk-in 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 questions come with the detailed explanation of the answers which helps in better understanding of C++ concepts.

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

1. What happens if try catch block is not used?
a) arise an error
b) program will run
c) execute continuously
d) wrong output
View Answer

Answer: a
Explanation: If try catch block is not used the exception thrown by the program will be uncaught hence will result into error(s).

2. Which handler is used to handle all types of exception?
a) catch handler
b) catch-all handler
c) catch-none handler
d) try-catch handler
View Answer

Answer: b
Explanation: To catch all types of exceptions, we use the catch-all handler.

3. Which operator is used as catch-all handler?
a) ellipses operator
b) ternary operator
c) string operator
d) unary operator
View Answer

Answer: a
Explanation: The ellipses operator can be represented as (…).

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Base
```
```
    {
```
```
        protected:
```
```
        int a;
```
```
        public:
```
```
        Base() 
```
```
        { 
```
```
            a = 34; 
```
```
        }
```
```
        Base(int i)
```
```
        { 
```
```
            a = i; 
```
```
        }
```
```
        virtual ~Base() 
```
```
        { 
```
```
            if (a < 0)  throw a; 
```
```
        }
```
```
        virtual int getA()
```
```
        {
```
```
            if (a < 0) 
```
```
            { 
```
```
                throw a;
```
```
            }
```
```
        }
```
```
    };
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            Base b(-25);
```
```
            cout << endl << b.getA();
```
```
        }
```
```
        catch (int) 
```
```
        {
```

            cout << endl << "Illegal initialization";

```
        }
```
```
    }
```

a) Illegal initialization
b) Terminate called after throwing an instance of ‘int’
c) Illegal initialization & terminate called after throwing an instance
d) initialization
View Answer

Answer: b
Explanation: As we are throwing a negative number and we are using the only integer, So it is arising an error.
Output:

Sanfoundry Certification Contest of the Month is Live. 100+ Subjects. Participate Now!

$ g++ uce.cpp
$ a.out
terminate called after throwing an instance of 'int'

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

```
    #include <iostream>
```
```
    #include <exception>
```
```
    using namespace std;
```
```
    void terminator()
```
```
    {
```
```
        cout << "terminate" << endl;
```
```
    }
```

    void (*old_terminate)() = set_terminate(terminator);

```
    class Botch 
```
```
    {
```
```
        public:
```
```
        class Fruit {};
```
```
        void f() 
```
```
        {
```
```
            cout << "one" << endl;
```
```
            throw Fruit();
```
```
        }
```
```
        ~Botch() 
```
```
        {
```
```
            throw 'c'; 
```
```
        }
```
```
    };
```
```
    int main() 
```
```
    {
```
```
        try 
```
```
        {
```
```
            Botch b;
```
```
            b.f();
```
```
        } 
```
```
        catch(...) 
```
```
        {
```

            cout << "inside catch(...)" << endl;

```
        }
```
```
    }
```

a) one
b) inside catch
c)

   one 
   terminate

   one 
   terminate
   Aborted

View Answer

Answer: d
Explanation: This program uses set_terminate as it is having an uncaught exception.
Output:

$ g++ uce1.cpp
$ a.out
one 
terminate
Aborted

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

```
    #include <iostream>
```
```
    #include <exception>
```
```
    #include <cstdlib>
```
```
    using namespace std;
```
```
    void myterminate () 
```
```
    {
```

        cerr << "terminate handler called";

```
        abort();
```
```
    }
```
```
    int main (void) 
```
```
    {
```
```
        set_terminate (myterminate);
```
```
        throw 0; 
```
```
        return 0;
```
```
    }
```

a) terminate handler called
b) aborted
c) both terminate handler & Aborted
d) runtime error
View Answer

Answer: c
Explanation: In this program, We are using set_terminate to abort the program.
Output:

$ g++ uce2.cpp
$ a.out
terminate handler called
Aborted

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    class Test1 
```
```
    { 
```
```
    };
```
```
    class Test2 : public Test1 { };
```
```
    void Funct();
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            Funct();
```
```
        }
```
```
        catch (const Test1&)
```
```
        {
```

            cerr << "Caught a exception" << endl;

```
        }
```
```
        return 0;
```
```
    }
```
```
    void Funct()
```
```
    {
```
```
        throw Test2();
```
```
    }
```

a) Caught an exception
b) NULL
c) Both Caught an exception & NULL
d) Caught a exception
View Answer

Answer: a
Explanation: In this program, We are arising with the exception by using the method in the class.
Output:

$ g++ uce3.cpp
$ a.out
Caught a exception

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

```
    #include <iostream>
```
```
    using namespace std;
```
```
    #include <cstdlib>
```
```
    #include <exception>
```
```
    void Funct()
```
```
    {
```

        cout << "Funct() was called by terminate()." << endl;

```
        exit(0);
```
```
    }
```
```
    int main()
```
```
    {
```
```
        try
```
```
        {
```
```
            set_terminate(Funct);
```
```
            throw "Out of memory!";
```
```
        }
```
```
        catch(int)
```
```
        { 
```

            cout << "Integer exception raised." << endl;

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

a) Integer exception raised
b) Funct() was called by terminate()
c) Integer exception not raised
d) Integer exception raised.
View Answer

Answer: b
Explanation: As there is no integer in this program, We are printing Funct() was called by terminate().
Output:

$ g++ uce4.cpp
$ a.out
Funct() was called by terminate().

9. What function will be called when we have an uncaught exception?
a) catch
b) throw
c) terminate
d) try
View Answer

Answer: c
Explanation: If we have an uncaught exception means, the compiler will throw the control of the program to terminate function.

10. What will not be called when the terminate() is raised in the constructor?
a) main()
b) class
c) destructor
d) constructor
View Answer

Answer: c
Explanation: To free the memory occupied by that object during initializing and destroy that object.

Sanfoundry Global Education & Learning Series – C++ Programming Language.

To practice all areas of C++ language, here is complete set of 1000+ Multiple Choice Questions and Answers.

If you find a mistake in question / option / answer, kindly take a screenshot and email to [email protected]

« Prev - C++ Programming Questions and Answers – Exception Specifications

» Next - C++ Programming Questions and Answers – Exceptions and Efficiency

Related Posts:

Recommended Articles: