Try–catch block in C++ - Step-by-Step Execution

Concept Flow - Try–catch block

Start

↓

Try block begins

↓

Code runs

↓

Exception thrown?

No→Try block ends normally

|Yes↓

Catch block matches exception

↓

Catch block runs

↓

Continue after catch

↓

End

The program tries code inside the try block. If an error (exception) happens, it jumps to the matching catch block to handle it, then continues.

Execution Sample

C++

try {
  int x;
  int denom = 0;
  if (denom == 0) {
    throw std::runtime_error("Division by zero");
  }
  x = 10 / denom;
  std::cout << "No error" << std::endl;
} catch (const std::exception& e) {
  std::cout << "Error caught" << std::endl;
}

This code checks for division by zero before dividing, which causes an exception caught by the catch block that prints an error message.

Execution Table

Step	Action	Evaluation	Result
1	Enter try block	Start executing code inside try	Proceed
2	Check for division by zero	Division by zero detected	Exception thrown
3	Jump to catch block	Catch block matches std::exception	Catch block runs
4	Execute catch block	Print "Error caught"	Output: Error caught
5	Exit try-catch	Continue normal flow	Program continues

💡 Exception thrown at division by zero, caught by catch block, program continues after handling

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
x	undefined	Exception thrown, no value assigned	No change	No value assigned

Key Moments - 2 Insights

Why does the program jump to the catch block instead of crashing?

Because an exception was thrown inside the try block (see Step 2 in execution_table), the program looks for a matching catch block to handle it (Step 3), preventing a crash.

Does the code after the error inside the try block run?

No, once the exception is thrown (Step 2), the rest of the try block is skipped and control moves to the catch block (Step 3).

Visual Quiz - 3 Questions

Look at the execution table, what happens at Step 2?

A The catch block starts running

B The division by zero causes an exception to be thrown

C The program prints "No error"

D The try block finishes normally

💡 Hint

Check the 'Evaluation' and 'Result' columns at Step 2 in the execution_table

At which step does the catch block execute?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'Jump to catch block' and 'Catch block runs' in the execution_table

If no exception was thrown, what would happen to the output?

A It would print "No error"

B It would print "Error caught"

C It would print nothing

D The program would crash

💡 Hint

Think about what happens if the try block finishes without exceptions (see Step 2 and exit_note)

Concept Snapshot

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

- Code in try runs normally
- If error occurs, jump to matching catch
- Catch handles error, program continues
- Prevents crashes by managing exceptions

Full Transcript

A try-catch block lets your program try some code that might cause an error. If an error happens, the program jumps to the catch block to handle it safely. This way, the program does not crash but continues running after dealing with the problem. In the example, a division by zero check throws an exception caught by the catch block, which prints an error message. The code after the error inside try does not run. The catch block runs only if an exception occurs.

Practice

1.

What is the main purpose of a try-catch block in C++?

easy

A. To handle errors and exceptions safely during program execution

B. To speed up the program by skipping code

C. To declare variables globally

D. To create loops that run multiple times

Solution

1. Step 1: Understand the role of try block

   The try block contains code that might cause an error or exception.

2. Step 2: Understand the role of catch block

   The catch block handles the error so the program does not crash.

3. Final Answer:

   To handle errors and exceptions safely during program execution -> Option A

4. Quick Check:

   Try-catch handles errors = B [OK]

Hint: Try-catch blocks catch errors to keep programs running [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 start a try block in C++?

?

easy

A. catch {

B. try (

C. try:

D. try {

Solution

1. Step 1: Recall try block syntax

   The try block starts with the keyword try followed by curly braces { }.

2. Step 2: Identify correct option

   Only try { uses try { which is correct syntax to start the block.

3. Final Answer:

   try { -> Option D

4. Quick Check:

   Try block starts with try { = C [OK]

Hint: Try block always starts with 'try {' in C++ [OK]

Common Mistakes:

• Using parentheses instead of curly braces
• Starting with catch instead of try
• Using colon after try

3.

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

try {
    int x = 5 / 0;
    std::cout << "Result: " << x << std::endl;
} catch (const std::exception& e) {
    std::cout << "Caught exception" << std::endl;
}

medium

A. Result: 0

B. Caught exception

C. Program crashes with division by zero error

D. No output

Solution

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

   Integer division by zero causes undefined behavior and usually crashes the program; it does not throw a standard exception.

2. Step 2: Check catch block type

   The catch block catches std::exception types, but division by zero does not throw this exception automatically.

3. Final Answer:

   Program crashes with division by zero error -> Option C

4. Quick Check:

   Integer division by zero crashes = D [OK]

Hint: Division by zero crashes, not caught by std::exception [OK]

Common Mistakes:

• Assuming catch block catches all errors
• Expecting output 'Caught exception'
• Thinking division by zero returns zero

4.

Identify the error in this C++ code snippet:

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

medium

A. The catch block for int should come after catch(...)

B. No error; code is correct

C. Multiple catch blocks are not allowed

D. Throwing int is invalid

Solution

1. Step 1: Check throw and catch types

   The code throws an int and catches it with catch(int e), which matches correctly.

2. Step 2: Verify catch block order

   The specific catch catch(int e) comes before the catch-all catch(...), which is correct.

3. Final Answer:

   No error; code is correct -> Option B

4. Quick Check:

   Throw int caught by int catch first = A [OK]

Hint: Specific catch blocks must come before catch(...) [OK]

Common Mistakes:

• Placing catch(...) before specific catch
• Thinking multiple catch blocks are invalid
• Believing throwing int is not allowed

5.

Consider this code snippet:

try {
    std::string s = "hello";
    int n = std::stoi(s);
    std::cout << n << std::endl;
} catch (const std::invalid_argument& e) {
    std::cout << "Invalid argument caught" << std::endl;
} catch (...) {
    std::cout << "Other exception caught" << std::endl;
}

What will be the output and why?

hard

A. Invalid argument caught

B. Other exception caught

C. hello

D. Program crashes

Solution

1. Step 1: Understand std::stoi behavior

   Trying to convert "hello" to int using std::stoi throws std::invalid_argument exception because "hello" is not a number.

2. Step 2: Check catch blocks

   The first catch block catches std::invalid_argument exceptions and prints "Invalid argument caught".

3. Final Answer:

   Invalid argument caught -> Option A

4. Quick Check:

   std::stoi throws invalid_argument for non-numeric string = A [OK]

Hint: std::stoi throws invalid_argument on bad input [OK]

Common Mistakes:

• Expecting program to print 'hello'
• Assuming catch(...) runs instead of specific catch
• Thinking program crashes without catch