Exception handling flow in C++ - Step-by-Step Execution

Concept Flow - Exception handling flow

Start

↓

Try block begins

↓

Code executes

↓

Exception thrown?

No→Try block ends normally

Yes↓

Catch block matches exception?

No→Unhandled exception, program terminates

Yes↓

Catch block executes

↓

Continue after catch

↓

End

The program runs code inside try. If an exception happens, it looks for a matching catch. If found, catch runs; otherwise, program stops.

Execution Sample

C++

try {
  int x = 5;
  if (x == 5) throw std::runtime_error("Error");
} catch (const std::exception& e) {
  std::cout << e.what();
}

This code throws an exception when x is 5 and catches it to print the error message.

Execution Table

Step	Action	Evaluation	Result
1	Enter try block	No exception yet	Proceed
2	Set x = 5	x = 5	x assigned
3	Check if x == 5	True	Condition met
4	Throw std::runtime_error	Exception thrown	Jump to catch
5	Catch block matches std::exception?	Yes	Catch executes
6	Print e.what()	"Error"	Output: Error
7	Exit catch block	No more code in try-catch	Program continues

💡 Exception caught and handled, normal program flow resumes

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 6	Final
x	undefined	5	5	5	5	5
exception	none	none	none	runtime_error thrown	caught with message 'Error'	caught

Key Moments - 3 Insights

Why does the program jump from the throw statement directly to the catch block?

When an exception is thrown (Step 4), normal code stops and control jumps to the matching catch block (Step 5), skipping remaining try code.

What happens if no catch block matches the thrown exception?

If no catch matches (not shown in table), the program terminates with an unhandled exception error.

Does the code after the throw inside try run?

No, after throw (Step 4), the try block stops immediately and control moves to catch.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after Step 3?

A 0

B undefined

C 5

D Exception object

💡 Hint

Check variable_tracker row for x at After Step 3 column

At which step does the exception get caught?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

Look at execution_table row where catch block matches exception

If the throw statement was removed, what would happen to the execution flow?

A Try block would finish normally, catch skipped

B Program would terminate with error

C Catch block would still execute

D Exception would be thrown later

💡 Hint

Refer to execution_table Step 4 and Step 5 for throw and catch relation

Concept Snapshot

try {
  // code that might throw
} catch (ExceptionType& e) {
  // handle exception
}

- Code in try runs normally
- If exception thrown, jump to matching catch
- If no catch matches, program ends
- After catch, program continues normally

Full Transcript

This visual trace shows how exception handling works in C++. The program starts by entering the try block and executing code. When the condition to throw an exception is met, the throw statement stops normal execution and jumps to the catch block that matches the exception type. The catch block runs and handles the error, for example by printing a message. After the catch block finishes, the program continues normally. If no catch block matches the exception, the program would terminate with an error. Variables like x keep their values through the process, but code after throw inside try does not run. This flow helps keep programs safe from unexpected errors by catching and managing exceptions.

Practice

1. What is the main purpose of using try and catch blocks in C++?

easy

A. To speed up the program execution

B. To handle errors and keep the program running smoothly

C. To declare variables

D. To create loops

Solution

1. Step 1: Understand the role of try block

   The try block contains code that might cause errors or exceptions during execution.

2. Step 2: Understand the role of catch block

   The catch block handles those errors so the program does not crash and can continue running.

3. Final Answer:

   To handle errors and keep the program running smoothly -> Option B

4. Quick Check:

   Exception handling = handle errors safely [OK]

Hint: Try-catch blocks catch errors to avoid crashes [OK]

Common Mistakes:

• Thinking try-catch speeds up code
• Confusing try-catch with loops
• Using try-catch to declare variables

2. Which of the following is the correct syntax to catch an exception of type int in C++?

easy

A. catch (int e) { /* handle error */ }

B. catch int (e) { /* handle error */ }

C. catch { int e; /* handle error */ }

D. catch (e int) { /* handle error */ }

Solution

1. Step 1: Recall correct catch syntax

   The catch block must specify the exception type in parentheses followed by a variable name, like catch (int e).

2. Step 2: Identify syntax errors in other options

   The other options contain syntax errors such as reversed type and variable order, incorrect keyword placement, or missing parentheses with improper declaration.

3. Final Answer:

   catch (int e) { /* handle error */ } -> Option A

4. Quick Check:

   Correct catch syntax = catch (type var) [OK]

Hint: Catch syntax: catch (type variable) { } [OK]

Common Mistakes:

• Omitting parentheses in catch
• Swapping type and variable order
• Missing variable name in catch

3. What will be the output of the following code?

try {
  throw 5;
  std::cout << "No Exception" << std::endl;
} catch (int e) {
  std::cout << "Caught exception: " << e << std::endl;
}

medium

A. Program crashes

B. No Exception

C. Caught exception: 5

D. No output

Solution

1. Step 1: Understand the throw statement

   The code throws an integer exception with value 5, so control jumps to the catch block immediately.

2. Step 2: Identify which catch block runs

   The catch block for int e catches the exception and prints the message with the value 5.

3. Final Answer:

   Caught exception: 5 -> Option C

4. Quick Check:

   Throw 5 caught by catch(int) = output message [OK]

Hint: Throw jumps to matching catch, skipping rest of try [OK]

Common Mistakes:

• Expecting code after throw to run
• Thinking program crashes without catch
• Ignoring exception value in output

4. Identify the error in this code snippet:

try {
  int x = 10 / 0;
} catch (double e) {
  std::cout << "Caught double exception" << std::endl;
}

medium

A. Division by zero causes a runtime error but no exception is thrown

B. Catch block should catch int, not double

C. Try block syntax is incorrect

D. No error, code runs fine

Solution

1. Step 1: Analyze division by zero in C++

   Integer division by zero causes undefined behavior or runtime error but does not throw a C++ exception automatically.

2. Step 2: Check catch block type

   The catch block expects a double exception, but no exception is thrown, so it never runs.

3. Final Answer:

   Division by zero causes a runtime error but no exception is thrown -> Option A

4. Quick Check:

   Integer divide by zero = runtime error, no catch [OK]

Hint: Integer divide by zero crashes, no catch thrown [OK]

Common Mistakes:

• Assuming division by zero throws exception
• Mismatching catch type with thrown exception
• Thinking try block syntax is wrong

5. Given this code, what will be the output?

try {
  try {
    throw std::string("Error");
  } catch (int e) {
    std::cout << "Caught int" << std::endl;
  }
} catch (std::string &e) {
  std::cout << "Caught string: " << e << std::endl;
}

hard

A. Caught int

B. Program crashes

C. No output

D. Caught string: Error

Solution

1. Step 1: Trace inner try-catch

   The inner try throws a std::string exception. The inner catch expects int, so it does not catch this exception.

2. Step 2: Trace outer catch block

   The exception propagates to the outer catch, which catches std::string &e and prints the message.

3. Final Answer:

   Caught string: Error -> Option D

4. Quick Check:

   Inner catch mismatch, outer catch handles string [OK]

Hint: Exception bubbles up until matching catch found [OK]

Common Mistakes:

• Assuming inner catch catches all exceptions
• Ignoring exception propagation
• Expecting program crash on uncaught inner exception