Why Try–catch block in C++? - Purpose & Use Cases

The Big Idea

What if your program could catch mistakes before they crash everything?

The Scenario

Imagine you are writing a program that reads a file and processes its content. Without any safety checks, if the file is missing or corrupted, your program just crashes suddenly, leaving users confused and frustrated.

The Problem

Manually checking every possible error before it happens is slow and complicated. You might miss some errors, causing your program to stop unexpectedly. This makes your code messy and hard to maintain.

The Solution

The try-catch block lets you wrap risky code in a safe container. If something goes wrong, the program jumps to the catch part where you can handle the error gracefully, like showing a friendly message or trying a backup plan.

Before vs After

✗ Before

if (file_exists) {
  read_file();
} else {
  print("Error: file missing");
}

✓ After

try {
  read_file();
} catch (const std::exception& e) {
  print("Error: file missing");
}

What It Enables

It enables your program to keep running smoothly even when unexpected problems happen, improving user experience and program reliability.

Real Life Example

Think of an online shopping app that tries to process payment. If the payment server is down, a try-catch block can catch that error and show a message like "Payment failed, please try again later" instead of crashing.

Key Takeaways

Try-catch blocks help handle errors without crashing the program.

They keep your code clean by separating normal logic from error handling.

They improve user experience by managing unexpected problems smoothly.

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