throw, try and catch in C++

Assertions give us a way to check for errors, but they have two limitations:

• They do not give us a way to recover from errors
• Because of that, they’re designed to be removed from the code in the builds we release to users, so they have no effect at all in production builds

To address these two limitations, we have dedicated key words within C++, and many similar languages: throw, try and catch.

Throwing errors with throw

Previously, we wrote this function using assert:

1#include <iostream>
2#include <cassert>
3
4int Divide(int x, int y) {
5  assert(y != 0 && "Cannot divide by zero");
6  return x/y;
7}
8
9int main() {
10  Divide(5, 0);
11}
12

Running this program, our crash dump would have looked something like this:

1main.cpp:5: int Divide(int, int):
2Assertion `y != 0 && "Cannot divide by zero"' failed.
3

Let's rewrite this example using throw instead:

1#include <iostream>
2
3int Divide(int x, int y) {
4  if (y == 0) throw "Cannot divide by zero";
5  return x/y;
6}
7
8int main() {
9  Divide(5, 0);
10}
11

Our crash dump now looks like this:

1terminate called after throwing an instance of 'char const*'
2

Our program terminates at the same point, although the error message is now less helpful. However, the benefit of using throw is that we can catch those errors, and recover from them.

Catching Exceptions with try and catch

In any function of our program, we can introduce an error boundary. Error boundaries catch any errors that were thrown as the result of executing a block of code.

They are comprised of two components - a try block and a catch block.

Within the try block, we place the code that might throw an exception.

Within the catch block, we place the code that will be called if an exception was indeed thrown.

1int main() {
2  try {
3    Divide(5, 0);
4  } catch (...) {
5    std::cout << "An error was caught";
6  }
7  std::cout << " but the program recovered";
8}
9

1An error was caught but the program recovered
2

As with most block statements within functions, we can elect to return early from a catch statement:

1int main() {
2  try {
3    Divide(5, 0);
4  } catch (...) {
5    std::cout << "An error was caught";
6    return -1;
7  }
8  std::cout << " but the program recovered";
9}
10

1An error was caught
2

Catching Specific Exceptions

Within the above example, the ... syntax within catch (...) indicates we want to catch all errors. This is generally not what we want - typically, we will want to catch errors of specific types. This gives us the added benefit of being able to access the actual exception that was thrown and inspect it.

We can throw any type of object as an exception.

In this case, we threw a simple primitive - the literal expression: "Cannot divide by zero". As indicated in the crash dump, this is an instance of const char*, ie, a C-style array of characters.

To access this object, we update our catch code to indicate it is only interested exceptions that have a type of const char*.

We also give that object a name so we can access it within the block of our catch statement. In this example, we called it simply Error:

1int main() {
2  try {
3    Divide(5, 0);
4  } catch (const char* Error) {
5    std::cout << "An error was caught: "
6              << Error << std::endl;
7  }
8  std::cout << "But the program recovered";
9}
10

1An error was caught: Cannot divide by zero
2But the program recovered
3

Catching Multiple Exception Types

We can catch multiple distinct exception types by using multiple catch statements:

1int Divide(int x, int y) {
2  if (y == 0) throw "Cannot divide by zero";
3  if (y == 1) throw -1;
4  if (y == 2) throw true;
5  return x/y;
6}
7
8int main() {
9  try {
10    Divide(5/0);
11    Divide(5/1);
12    Divide(5/2);
13  } catch (const char* Error) {
14    // A const char* was thrown
15  } catch (int Error) {
16    // An int was thrown
17  }
18}
19

In this example, the const char* error thrown by the first call to Divide will be caught by the first catch statement.

The int error thrown by the second call to Divide will be caught by the second catch statement.

The bool error thrown by the third call to Divide will not be caught. This is frequently referred to as an “uncaught exception”. If our program throws an exception that is never caught, it will terminate.

In this case, the crash dump might report something like:

1terminate called after throwing an instance of 'bool'
2

Custom Exception Types

Generally, we don’t want to be throwing arbitrary objects like strings and integers. Instead, we should use a type of object dedicated to this purpose.

The standard library comes with a range of such types, that all inherit from a base std::exception class. We can also create our own exception types, specific to our use case, by creating our own classes that inherit from std::exception

This would give us a standardized, structured way of creating exceptions. We will cover this in the next lesson