Multiple catch blocks in C++ - Step-by-Step Execution

Concept Flow - Multiple catch blocks

Try block starts

↓

Exception thrown?

No→Try block ends normally

Yes↓

Check first catch block

↓

Matches exception type?

No→Check next catch block

Yes↓

Execute catch block

↓

Continue after try-catch

The program tries code inside try. If an exception happens, it checks each catch block in order to find a matching type and runs that catch block.

Execution Sample

C++

try {
  throw 10;
} catch (int e) {
  std::cout << "Caught int: " << e;
} catch (...) {
  std::cout << "Caught unknown";
}

This code throws an int exception and catches it with the matching int catch block.

Execution Table

Step	Action	Exception Type	Catch Block Checked	Match?	Output
1	Enter try block	None	None	N/A
2	Throw exception	int (10)	First catch (int e)	Yes	Caught int: 10
3	Catch block executed	int (10)	First catch (int e)	Yes	Caught int: 10
4	Skip other catch blocks	int (10)	Second catch (...)	No
5	Continue after try-catch	None	None	N/A

💡 Exception matched first catch block (int), so no further catch blocks checked.

Variable Tracker

Variable	Start	After throw	After catch	Final
e	undefined	10 (thrown)	10 (caught)	10 (caught)

Key Moments - 2 Insights

Why does the first catch block run and not the second?

Because the thrown exception is an int, it matches the first catch block's type int (see execution_table step 2). The second catch block is for any type (...), but it is skipped once a match is found.

What happens if no catch block matches the exception?

If no catch block matches, the exception is not handled here and will propagate up. In the table, if no 'Match?' is Yes, the program would terminate or look for another handler.

Visual Quiz - 3 Questions

Look at the execution table, which catch block handles the exception at step 2?

A First catch block (int e)

B Second catch block (...)

C No catch block handles it

D Both catch blocks handle it

💡 Hint

Check the 'Catch Block Checked' and 'Match?' columns at step 2 in the execution_table.

At which step does the program continue after handling the exception?

A Step 4

B Step 5

C Step 3

D Step 2

💡 Hint

Look for the step labeled 'Continue after try-catch' in the execution_table.

If the thrown exception was a string instead of int, which catch block would handle it?

A First catch block (int e)

B No catch block

C Second catch block (...)

D Both catch blocks

💡 Hint

The first catch only matches int, the second catch (...) matches any type (see concept_flow).

Concept Snapshot

try {
  // code that may throw
} catch (Type1 e) {
  // handle Type1 exceptions
} catch (Type2 e) {
  // handle Type2 exceptions
} catch (...) {
  // handle any exception
}

- Multiple catch blocks checked in order
- First matching catch runs
- Others skipped after match

Full Transcript

In C++, you can use multiple catch blocks after a try block to handle different types of exceptions. When an exception is thrown inside the try block, the program checks each catch block in order to find one whose type matches the thrown exception. The first matching catch block runs, and the others are skipped. If no catch block matches, the exception propagates further. This example throws an int exception and catches it with the first catch block that handles int. The second catch block with ... is a catch-all but is not reached here. Variables like the exception object 'e' get assigned the thrown value when caught. This flow helps handle different errors differently in your program.

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