Function Try Blocks

1#include <iostream>
2#include <stdexcept>
3
4void MyFunction() {
5  try {
6    throw std::runtime_error { "Oops!" };
7  } catch (std::runtime_error& e) {
8    std::cout << "Error: " << e.what();
9  }
10}
11
12int main() {
13  MyFunction();
14}

1Error: Oops!

There is an alternative syntax for this, where we want the try and catch to apply to our whole function. It looks like this:

1#include <iostream>
2#include <stdexcept>
3
4void MyFunction() try {
5  throw std::runtime_error { "Oops!" };
6} catch (std::runtime_error& e) {
7  std::cout << e.what();
8}
9
10int main() {
11  MyFunction();
12}

1Error: Oops!

As with regular try-catch blocks, we can have multiple catch statements, to catch different types of errors thrown within our function body:

1#include <iostream>
2#include <stdexcept>
3
4void MyFunction() try {
5  throw std::runtime_error { "Oops!" };
6} catch (std::logic_error& e) {
7  std::cout << "Logic error!";
8} catch (std::runtime_error& e) {
9  std::cout << "Runtime error!";
10}
11
12int main() {
13  MyFunction();
14}

1Runtime error!

As usual, the exception we're catching doesn't need to be directly thrown within the associated body. We can catch exceptions that bubbled up the call stack:

1#include <iostream>
2#include <stdexcept>
3
4void ThrowException() {
5  throw std::runtime_error{"Oops!"};
6}
7
8void MyFunction() try {
9  ThrowException();
10} catch (std::runtime_error& e) {
11  std::cout << "Runtime error!";
12}
13
14int main() {
15  MyFunction();
16}

1Runtime error!

Where the function has a non-void return type, all of the catch statements will also need to respect that, by returning an appropriate object:

1#include <exception>
2
3int Divide(int x, int y) try {
4  if (y == 0) {
5    throw std::invalid_argument{
6      "Cannot divide by zero"};
7  }
8  return x/y;  
9} catch (std::invalid_argument& e) {
10  return -1;  
11}

Naturally, we can get the same behavior of a function try block by simply having the entire body of the function be a try-catch block.

So in the previous examples, the function try block isn't helping us achieve anything we couldn't before - although it could be argued that the syntax is more readable.

However, some exceptions can only be caught by a function try block: specifically, exceptions that occur in member initializer lists.

In the following example, the Enemy constructor is going to receive an exception. However, the exception is coming from the member initializer list, outside of the function body:

1#include <iostream>
2#include <stdexcept>
3
4int GetHealth(int Health) {
5  if (Health < 0) throw std::logic_error{
6    "Health cannot be negative"};
7
8  return Health;
9}
10
11class Enemy {
12public:
13  Enemy(int Health)
14    : mHealth{GetHealth(Health)} {}
15
16 private:
17  int mHealth;
18};
19
20int main() {
21  Enemy Goblin { -100 };
22}

1terminate called after throwing an instance of std::logic_error

When a member initializer list throws an exception, a function try block is the only way to catch that exception:

1#include <iostream>
2#include <stdexcept>
3
Unchanged Code|Show
4int GetHeath(int Health) {/*...*/}
11
12class Enemy {
13public:
14  Enemy(int Health) try
15  : mHealth{GetHealth(Health)} {
16    // ... Constructor body
17  } catch (std::logic_error& e) {
18    std::cout << e.what();
19  }
20
21 private:
22  int mHealth;
23};
24
25int main() {
26  Enemy Goblin { -100 };
27}

We now get our custom error message:

1Health cannot be negative
2terminate called after throwing an instance of 'std::logic_error'

The previous output shows that our program is still terminated, even though we caught the exception.

When an exception is thrown as part of a constructor's function-try block, it is impossible to recover from that within the associated catch blocks.

We need to re-throw the exception, or throw a different exception. If we don't rethrow the exception, it will be implicitly rethrown for us.

Either way, an exception escapes from the constructor, and needs to be handled elsewhere in the stack:

1#include <iostream>
2#include <stdexcept>
3
Unchanged Code|Show
4int GetHeath(int Health) {/*...*/}
11
Unchanged Code|Show
12class Enemy {/*...*/}
25
26int main() {
27  try {
28    Enemy Goblin { -100 };
29  } catch (std::exception& e) {
30    std::cout << "\nGoblin construction failed";
31  }
32  std::cout << " but we recovered";
33}

1Health cannot be negative
2Goblin construction failed but we recovered

Therefore, the use of function try blocks within constructors has two purposes:

• To change the type of error thrown, by rethrowing a different type
• For secondary effects - eg, reporting the error to some tracker

In this lesson, we explored the concept and application of function try blocks in C++. In particular, we emphasized their unique ability to handle exceptions from member initializer lists in constructors. The key takeaways include:

• Function try blocks are special try-catch constructs that can catch exceptions thrown anywhere within a function, including member initializer lists.
• In constructors, function try blocks are the only means to catch exceptions arising from member initializer lists.
• When an exception is caught in a constructor's function-try block, it cannot be fully recovered within the catch block; it must be re-thrown or replaced with another exception.
• Function try blocks in non-void functions require that all catch blocks respect the function's return type.
• The primary uses of function try blocks in constructors are to modify the type of thrown exception and to perform secondary actions, like error logging.