Function Try Block vs Regular Try-Catch

Function try blocks and regular try-catch blocks serve different purposes and are used in different scenarios. Here are some guidelines on when to use each:

Use a function try block when:

1. You want to catch exceptions that are thrown from the member initializer list of a constructor.
2. You want to apply exception handling to the entire function body without explicitly wrapping it in a try block.

Use a regular try-catch block when:

1. You want to catch exceptions within a specific block of code inside a function.
2. You want to have different exception handling for different parts of the function.

Here's an example that illustrates the difference:

1#include <iostream>
2#include <stdexcept>
3
4class MyClass {
5 public:
6  MyClass(int value) try : mValue{value} {
7    // Constructor body
8    throw std::exception{"Constructor error"};
9  } catch (...) {
10    std::cout << "Exception caught in "
11      "constructor\n";
12    throw;
13  }
14
15  void doSomething() {
16    try {
17      if (mValue < 0) {
18        throw std::invalid_argument{
19          "Negative value"};
20      }
21      // Regular function code
22    } catch (const std::exception& e) {
23      std::cout << "Exception caught in "
24        "doSomething(): " << e.what() << "\n";
25    }
26  }
27
28 private:
29  int mValue;
30};
31
32int main() {
33  try {
34    MyClass obj{-5};
35    obj.doSomething();
36  } catch (const std::exception& e) {
37    std::cout << "Exception caught in main(): "
38      << e.what() << "\n";
39  }
40}

1Exception caught in constructor
2Exception caught in doSomething(): Negative value

In this example:

• The constructor of MyClass uses a function try block to catch any exceptions thrown during the initialization of mValue. This is necessary because the member initializer list is outside the constructor body.
• The doSomething() function uses a regular try-catch block to catch exceptions within a specific part of the function. This allows for localized exception handling.

In the main() function, a MyClass object is created with a negative value, which throws an exception in the constructor. The exception is caught and handled in the function try block of the constructor.

Then, when doSomething() is called, it throws an exception due to the negative value, which is caught and handled within the regular try-catch block inside the function.

So, use function try blocks when you need to catch exceptions in the entire function body or in the member initializer list of a constructor, and use regular try-catch blocks for localized exception handling within a function.