Catching All Exceptions

To catch all exceptions in a function try block, you can use the ellipsis (...) as the exception type in the catch block. This is known as a catch-all handler and it will catch any type of exception that is thrown within the function try block.

Here's an example:

1#include <iostream>
2#include <stdexcept>
3
4void processValue(int value) try {
5  if (value < 0) {
6    throw std::invalid_argument{"Negative value"};
7  }
8  if (value == 0) {
9    throw std::runtime_error{"Zero value"};
10  }
11// Process the value
12} catch (...) {
13  std::cout << "An exception occurred\n";
14}
15
16int main() {
17  processValue(42);
18  processValue(-5);
19  processValue(0);
20}

1An exception occurred
2An exception occurred

In this example, the processValue function uses a function try block to catch any exceptions that may be thrown. The catch block uses the ellipsis (...) to catch all types of exceptions.

Inside the function, different exceptions (std::invalid_argument and std::runtime_error) are thrown based on the value of the parameter. However, the catch-all handler catches both exceptions and prints a generic message.

When processValue is called with different values in the main() function, the exceptions are caught by the catch-all handler, and the corresponding message is printed.

Using a catch-all handler can be useful when you want to handle all exceptions in a generic way, without specifying each exception type explicitly. However, it's generally recommended to catch specific exceptions whenever possible, as it provides more control and allows for targeted exception handling.

If you need to access the caught exception object in the catch-all handler, you can rethrow it to another catch block that catches a specific exception type or a base class of the exception hierarchy.

1#include <stdexcept>
2#include <iostream>
3
4void processValue(int value) try {
5  // ...
6} catch (...) {
7  std::cout << "An exception occurred\n";
8  throw;  // Rethrow the exception
9}
10
11int main() {
12  try {
13    processValue(42);
14    processValue(-5);
15    processValue(0);
16  } catch (const std::exception& e) {
17    std::cout << "Exception caught: "
18      << e.what() << "\n";
19  }
20}

In this modified example, the catch-all handler rethrows the caught exception using throw. The exception is then caught in the main() function by a catch block that catches std::exception, which is a base class for many standard exception types. This allows you to access the exception object and retrieve more information about the exception.

Remember, while catch-all handlers can be convenient, it's generally better to catch specific exceptions when possible to handle them appropriately based on their type.