Exception handling flow in C++ - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested try-catch blocks

What is the output of this C++ code when executed?

C++

#include <iostream>

int main() {
    try {
        try {
            throw 10;
        } catch (int e) {
            std::cout << "Inner catch: " << e << std::endl;
            throw;
        }
    } catch (int e) {
        std::cout << "Outer catch: " << e << std::endl;
    }
    return 0;
}

A No output, program terminates silently

B

Inner catch: 10
Outer catch: 10

C Outer catch: 10

D Inner catch: 10

💡 Hint

Remember that rethrowing an exception passes it to the next matching catch block outside.

The inner try throws 10, caught by inner catch which prints and rethrows. The outer catch then catches and prints again.

❓ Predict Output

intermediate

Exception caught by base class catch block

What will be the output of this C++ program?

C++

#include <iostream>
#include <exception>

class MyException : public std::exception {};

int main() {
    try {
        throw MyException();
    } catch (std::exception& e) {
        std::cout << "Caught std::exception" << std::endl;
    } catch (...) {
        std::cout << "Caught unknown exception" << std::endl;
    }
    return 0;
}

A Caught std::exception

B No output

C Caught unknown exception

D Compilation error

💡 Hint

MyException inherits from std::exception, so it matches the first catch.

Since MyException is derived from std::exception, the first catch block handles it.

❓ Predict Output

advanced

Exception propagation with function calls

What is the output when this C++ program runs?

C++

#include <iostream>

void funcB() {
    throw "Error in funcB";
}

void funcA() {
    try {
        funcB();
    } catch (const char* msg) {
        std::cout << "Caught in funcA: " << msg << std::endl;
        throw;
    }
}

int main() {
    try {
        funcA();
    } catch (const char* msg) {
        std::cout << "Caught in main: " << msg << std::endl;
    }
    return 0;
}

A Caught in funcA: Error in funcB

B Caught in main: Error in funcB

C

Caught in funcA: Error in funcB
Caught in main: Error in funcB

D No output, program crashes

💡 Hint

Exception thrown in funcB is caught and rethrown in funcA, then caught in main.

funcB throws, funcA catches and prints, then rethrows. main catches and prints again.

❓ Predict Output

advanced

Exception handling with multiple catch blocks

What output does this program produce?

C++

#include <iostream>

int main() {
    try {
        throw 3.14;
    } catch (int e) {
        std::cout << "Caught int: " << e << std::endl;
    } catch (double e) {
        std::cout << "Caught double: " << e << std::endl;
    } catch (...) {
        std::cout << "Caught unknown" << std::endl;
    }
    return 0;
}

A Caught double: 3.14

B Caught int: 3

C Caught unknown

D No output

💡 Hint

The thrown value is a double, so the matching catch block handles it.

The throw is a double, so the catch(double) block runs and prints the value.

🧠 Conceptual

expert

Exception handling order and program termination

Consider this C++ code snippet. What happens when an exception is thrown but not caught anywhere?

C++

#include <iostream>
#include <stdexcept>

void func() {
    throw std::runtime_error("Error");
}

int main() {
    func();
    std::cout << "End of main" << std::endl;
    return 0;
}

A Program prints "End of main" and then throws exception

B "End of main" is printed, then program terminates normally

C Program compiles but does nothing

D Program terminates with uncaught exception error, "End of main" is not printed

💡 Hint

If no catch block handles the exception, the program ends abruptly.

Since no catch block handles the thrown exception, the program terminates immediately without printing "End of main".