C++ Function Try Blocks

When developing programs in C++, it's essential to handle exceptions that can occur during program execution. One way to handle these exceptions is by using function try blocks.

A function try-catch block is a special type of try-catch block that is used to catch exceptions thrown anywhere within the function that it is applied to. In this article, we will explain the basics of function try-catch blocks and show you how to use them in your code.

Previously, we have seen how we can have try and catch blocks inside a function:

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 << e.what();
9  }
10}
11

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

As with regular try-catch blocks, we can have multiple catch statements, to catch different types of errors:

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

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:

1int GetNumber() try {
2  throw std::runtime_error { "Oops!" };
3  return 42;
4} catch (std::runtime_error e) {
5  std::cout << e.what();
6  return -1;
7}
8

Catching Exceptions in Member Initialization Lists

Function try blocks are particularly useful when we want to catch exceptions within a class constructor. In the following example, line 13 is making a call to the Character constructor, passing a value that is going to cause an exception.

But, how do we catch that exception within the Goblin constructor?

1#include <iostream>
2#include <stdexcept>
3
4class Character {
5public:
6  Character(int Health) {
7    if (Health < 0) throw std::logic_error {
8      "Health cannot be negative!"
9    };
10  }
11};
12
13class Goblin : Character {
14public:
15  Goblin(int Health) : Character { Health } {
16    // How can we catch the error??
17  }
18};
19
20int main() {
21  Goblin MyChar { -100 };
22}
23

Our program crashes without showing our error:

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

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

1class Goblin : Character {
2public:
3  Goblin(int Health) try : Character { Health } {
4    // How can we catch the error??
5  } catch (std::logic_error e) {
6    std::cout << e.what() << std::endl;
7  }
8};
9

We now get our custom error message:

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

When an exception is thrown as part of a constructor, it is not possible to recover from that within the constructor. We just need to rethrow the error.

If we don’t rethrow the error, it will be implicitly rethrown for us, as indicated by the second line of our previous error log.

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