Multiple catch blocks in C++ - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch an integer exception.

C++

#include <iostream>

int main() {
    try {
        throw 10;
    } catch ([1]) {
        std::cout << "Caught an integer exception." << std::endl;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

Astd::string e

Bint e

Cfloat e

Dchar e

Attempts:

3 left

💡 Hint

Common Mistakes

Using a catch type that does not match the thrown exception type.

Omitting the exception variable name.

The catch block must specify the type of exception it handles. Here, int e catches integer exceptions.

2fill in blank

medium

Complete the code to catch a standard exception by reference.

C++

#include <iostream>
#include <exception>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("Error occurred");
    } catch (const [1]& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

Astd::exception

Bint

Cchar

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Catching by value instead of by reference.

Using a non-related type in catch.

Standard exceptions are caught by reference to std::exception or its derived classes.

3fill in blank

hard

Fix the error in the catch block to properly catch a double exception.

C++

#include <iostream>

int main() {
    try {
        throw 3.14;
    } catch ([1]) {
        std::cout << "Caught a double exception." << std::endl;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

Adouble e

Bint e

Cfloat e

Dchar e

Attempts:

3 left

💡 Hint

Common Mistakes

Using int e or float e to catch a double exception.

Omitting the exception variable name.

The thrown value is a double, so the catch block must specify double e to catch it correctly.

4fill in blank

hard

Fill both blanks to catch exceptions of type int and std::string separately.

C++

#include <iostream>
#include <string>

int main() {
    try {
        throw [1];
    } catch ([2] e) {
        std::cout << "Caught int exception: " << e << std::endl;
    } catch (std::string e) {
        std::cout << "Caught string exception: " << e << std::endl;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

A10

Bstd::string("error")

Cint

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing a string but catching an int.

Mismatching catch types.

The thrown exception is an integer 10, so the first catch must handle int type.

5fill in blank

hard

Fill all three blanks to catch exceptions of type float, int, and std::exception.

C++

#include <iostream>
#include <exception>

int main() {
    try {
        throw [1];
    } catch ([2] e) {
        std::cout << "Caught float exception: " << e << std::endl;
    } catch ([3] e) {
        std::cout << "Caught int exception: " << e << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Caught std::exception: " << e.what() << std::endl;
    }
    return 0;
}

Drag options to blanks, or click blank then click option'

A3.14f

Bfloat

Cint

Ddouble

Attempts:

3 left

💡 Hint

Common Mistakes

Using double literal instead of float.

Mixing catch types order.

The thrown exception is a float literal 3.14f, so the first catch handles float. The second catch handles int exceptions.

Practice

1.

What is the main purpose of using multiple catch blocks in C++?

easy

A. To speed up the program execution

B. To handle different types of exceptions separately

C. To avoid using try blocks

D. To declare multiple variables at once

Solution

1. Step 1: Understand the role of catch blocks

   Catch blocks are used to handle exceptions that occur in the try block.

2. Step 2: Recognize the benefit of multiple catch blocks

   Multiple catch blocks allow handling different exception types separately, so each error can be managed properly.

3. Final Answer:

   To handle different types of exceptions separately -> Option B

4. Quick Check:

   Multiple catch blocks = handle different exceptions [OK]

Hint: Multiple catch blocks handle different errors separately [OK]

Common Mistakes:

• Thinking multiple catch blocks speed up code
• Confusing catch blocks with variable declarations
• Believing try blocks are not needed with multiple catch blocks

2.

Which of the following is the correct syntax to catch any remaining exceptions in multiple catch blocks in C++?

try {
    // code
}
catch (int e) {
    // handle int
}
_____ {
    // handle other
}

easy

A. catch (...)

B. catch (string e)

C. catch (double e)

D. catch (char e)

Solution

1. Step 1: Identify the syntax for catch-all block

   The catch(...) block catches any exception type not caught by previous catch blocks.

2. Step 2: Confirm correct syntax

   Only catch(...) uses ellipsis and no variable type, making it the correct syntax for a generic catch block.

3. Final Answer:

   catch (...) -> Option A

4. Quick Check:

   catch(...) = catch all exceptions [OK]

Hint: Use catch(...) to catch all exceptions generically [OK]

Common Mistakes:

• Using catch without parentheses
• Trying to catch unknown types without ellipsis
• Misplacing catch blocks after try

3.

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

try {
    throw 10;
}
catch (double e) {
    std::cout << "Double exception";
}
catch (int e) {
    std::cout << "Integer exception: " << e;
}

medium

A. Compilation error

B. Double exception

C. No output

D. Integer exception: 10

Solution

1. Step 1: Identify the thrown exception type

   The code throws an integer exception with value 10.

2. Step 2: Match thrown exception with catch blocks

   The first catch block expects a double, so it is skipped. The second catch block matches int, so it executes and prints the message.

3. Final Answer:

   Integer exception: 10 -> Option D

4. Quick Check:

   throw int = catch int block runs [OK]

Hint: Match thrown type with catch parameter type [OK]

Common Mistakes:

• Assuming first catch always runs
• Confusing int and double types
• Expecting no output if types differ

4.

Find the error in this code snippet using multiple catch blocks:

try {
    throw "error";
}
catch (int e) {
    std::cout << "Int error";
}
catch (char e) {
    std::cout << "Char error";
}

medium

A. Missing catch block for const char* exception

B. Try block syntax is incorrect

C. Cannot throw string literals

D. Catch blocks must be in reverse order

Solution

1. Step 1: Identify the thrown exception type

   The code throws a string literal, which is of type const char*.

2. Step 2: Check catch blocks for matching types

   Catch blocks handle int and char, but not const char*. So no catch block matches the thrown exception, causing an unhandled exception.

3. Final Answer:

   Missing catch block for const char* exception -> Option A

4. Quick Check:

   Thrown type must match catch parameter [OK]

Hint: Catch blocks must match thrown exception types exactly [OK]

Common Mistakes:

• Assuming char catch handles string literals
• Thinking try block syntax is wrong
• Believing catch order matters for unrelated types

5.

Consider this code with multiple catch blocks:

try {
    throw std::runtime_error("runtime error");
}
catch (std::exception& e) {
    std::cout << "Exception: " << e.what();
}
catch (std::runtime_error& e) {
    std::cout << "Runtime error: " << e.what();
}

What will be the output and why?

hard

A. Exception: runtime error

B. Runtime error: runtime error

C. Compilation error due to catch order

D. No output because exception is not caught

Solution

1. Step 1: Understand exception inheritance

   std::runtime_error is derived from std::exception, so it matches both catch blocks.

2. Step 2: Analyze catch block order

   The first catch block catches std::exception by reference, so it catches the thrown runtime_error before the second catch block is reached.

3. Step 3: Determine output

   The first catch block prints "Exception: runtime error" using e.what().

4. Final Answer:

   Compilation error due to catch order -> Option C

5. Quick Check:

   Derived class catch must come before base class catch to avoid compilation error [OK]

Hint: Catch derived exceptions before base to avoid compilation error [OK]

Common Mistakes:

• Expecting derived catch to run first
• Thinking catch order causes no compilation error
• Assuming no output if multiple matches