Why exception handling is required in C++ - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch an exception thrown by the division by zero.

C++

#include <iostream>
int main() {
    try {
        int a = 10, b = 0;
        if (b == 0) throw [1];
        std::cout << a / b << std::endl;
    } catch (int e) {
        std::cout << "Exception caught: division by zero" << std::endl;
    }
    return 0;
}

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

A1

B0

Cb

Da

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing a variable that is zero poorly signals an error.

Throwing the variable 'b' which is zero is not meaningful here.

Throwing an integer value like 1 is a simple way to signal an exception in C++.

2fill in blank

medium

Complete the code to handle an exception of type std::string.

C++

#include <iostream>
#include <string>
int main() {
    try {
        throw std::string("Error occurred");
    } catch ([1] e) {
        std::cout << "Caught exception: " << e << std::endl;
    }
    return 0;
}

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

Aint

Bstd::string

Cfloat

Dchar

Attempts:

3 left

💡 Hint

Common Mistakes

Catching with int or char causes a mismatch and no catch.

Catching with float is incorrect for string exceptions.

The catch block must match the thrown exception type, which is std::string here.

3fill in blank

hard

Fix the error in the code by completing the catch block to handle all exceptions.

C++

#include <iostream>
int main() {
    try {
        throw 20;
    } catch ([1]) {
        std::cout << "Exception caught" << std::endl;
    }
    return 0;
}

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

Afloat e

Bchar e

Cint e

D...

Attempts:

3 left

💡 Hint

Common Mistakes

Using catch(int e) only catches int exceptions.

Using catch(char e) or catch(float e) misses other types.

Using catch(...) catches any type of exception regardless of its type.

4fill in blank

hard

Fill both blanks to throw and catch a custom exception class.

C++

#include <iostream>
class MyException {
public:
    const char* what() const { return "Custom exception"; }
};
int main() {
    try {
        throw [1];
    } catch ([2]& e) {
        std::cout << e.what() << std::endl;
    }
    return 0;
}

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

AMyException()

Bint

CMyException

Dstd::exception

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing the class name instead of an instance causes errors.

Catching by value instead of reference can cause slicing.

Throw an instance of MyException and catch it by reference to MyException.

5fill in blank

hard

Fill all three blanks to create a try-catch block that throws an integer, catches it, and prints the value.

C++

#include <iostream>
int main() {
    try {
        throw [1];
    } catch ([2] e) {
        std::cout << "Caught value: " << [3] << std::endl;
    }
    return 0;
}

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

A42

Bint

Ce

Dfloat

Attempts:

3 left

💡 Hint

Common Mistakes

Throwing a float but catching int causes mismatch.

Printing a variable not declared in catch causes errors.

Throw integer 42, catch as int, and print the caught variable e.

Practice

1. Why is exception handling required in C++ programs?

easy

A. To write code without using functions

B. To make the program run faster

C. To catch and manage runtime errors without crashing the program

D. To avoid using variables

Solution

1. Step 1: Understand the purpose of exception handling

   Exception handling is used to catch errors that happen while the program runs, so the program can respond properly.

2. Step 2: Identify the benefit of managing errors

   By managing errors, the program avoids crashing and can show helpful messages or recover safely.

3. Final Answer:

   To catch and manage runtime errors without crashing the program -> Option C

4. Quick Check:

   Exception handling = catch errors safely [OK]

Hint: Exception handling prevents crashes by managing errors [OK]

Common Mistakes:

• Thinking exception handling speeds up the program
• Confusing exception handling with code optimization
• Believing exception handling removes the need for variables

2. Which of the following is the correct syntax to start an exception handling block in C++?

easy

A. try { }

B. catch { }

C. except { }

D. handle { }

Solution

1. Step 1: Recall the keywords for exception handling

   C++ uses try to start a block where exceptions might occur, and catch to handle them.

2. Step 2: Identify the correct starting keyword

   The block that contains code that might throw an exception must start with try.

3. Final Answer:

   try { } -> Option A

4. Quick Check:

   Start exception block with try [OK]

Hint: Exception blocks start with try, not catch or except [OK]

Common Mistakes:

• Using catch to start the block instead of try
• Confusing C++ syntax with other languages like Python
• Using non-existent keywords like except or handle

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

try {
  throw 10;
  std::cout << "No Exception";
} catch (int e) {
  std::cout << "Exception caught: " << e;
}

medium

A. Exception caught: 10

B. No Exception

C. Compilation error

D. No output

Solution

1. Step 1: Understand the throw statement

   The code throws an integer exception with value 10, so the normal flow stops at throw 10;.

2. Step 2: Check the catch block

   The catch block catches an integer exception and prints "Exception caught: 10".

3. Final Answer:

   Exception caught: 10 -> Option A

4. Quick Check:

   Throw 10 caught prints message [OK]

Hint: Throw stops try block; catch prints exception [OK]

Common Mistakes:

• Expecting code after throw to run
• Thinking no output appears
• Confusing syntax causing compile errors

4. Identify the error in this C++ exception handling code:

try {
  int x = 5 / 0;
} catch (int e) {
  std::cout << "Error: " << e;
}

medium

A. Division by zero causes a compile-time error

B. No exception is thrown for division by zero automatically

C. Exception type int does not match thrown error

D. Missing catch block for double type

Solution

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

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

2. Step 2: Check exception handling mechanism

   Since no exception is thrown, the catch block will not execute, and the program may crash or behave unpredictably.

3. Final Answer:

   No exception is thrown for division by zero automatically -> Option B

4. Quick Check:

   Division by zero doesn't throw exceptions by default [OK]

Hint: Division by zero doesn't throw exceptions automatically [OK]

Common Mistakes:

• Assuming division by zero throws int exception
• Expecting compile-time error for division by zero
• Ignoring undefined behavior risks

5. You want to safely read an integer from user input and handle invalid input without crashing. Which approach best uses exception handling in C++?

hard

A. Use only catch block without try

B. Use if-else to check input and ignore exceptions

C. Use try block but no catch block

D. Use try block to read input and catch std::exception to handle errors

Solution

1. Step 1: Understand safe input reading

   Reading input can fail if user enters invalid data, so using try-catch helps handle exceptions gracefully.

2. Step 2: Identify correct exception handling structure

   Using a try block to attempt reading input and catching std::exception or related exceptions allows handling errors without crashing.

3. Final Answer:

   Use try block to read input and catch std::exception to handle errors -> Option D

4. Quick Check:

   Try-catch safely handles input errors [OK]

Hint: Use try-catch to handle input errors safely [OK]

Common Mistakes:

• Not using catch block after try
• Ignoring exceptions and using only if-else
• Using catch without try block