Handling Multiple Exception Types in a Single Catch Block

Yes, it is possible to catch and handle multiple exception types in a single catch block using the std::exception base class. First, declare a catch block that catches exceptions of type std::exception&:

1try {
2  // Code that may throw exceptions
3} catch (const std::exception& e) {
4  // Handle the exception
5}

Inside the catch block, you can use the dynamic_cast operator to determine the specific type of exception that was caught:

1try {
2  // Code that may throw exceptions
3} catch (const std::exception& e) {
4  if (dynamic_cast<const TypeA*>(&e)) {
5    // Handle exceptions of type TypeA
6  } else if (dynamic_cast<const TypeB*>(&e)) {
7    // Handle exceptions of type TypeB
8  } else {
9    // Handle other std::exception-derived types
10  }
11}

Alternatively, you can use the typeid operator to get information about the caught exception type:

1try {
2  // Code that may throw exceptions
3} catch (const std::exception& e) {
4  if (typeid(e) == typeid(TypeA)) {
5    // Handle TypeA
6  } else if (typeid(e) == typeid(TypeB)) {
7    // Handle TypeB
8  } else {
9    // Handle other std::exception-derived types
10  }
11}

By catching the base std::exception class, you can handle multiple exception types derived from std::exception in a single catch block. This allows you to centralize the exception handling logic and perform specific actions based on the actual exception type.

However, keep in mind that catching exceptions by reference to the base class may limit your ability to access exception-specific data or functions. If you need to access such data or functions, you may need to catch the specific exception types individually.