Exceptions: throw, try and catch

Previously, we wrote this function using assert():

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

Running this program, our output may have looked something like this:

1Assertion failed: y != 0 && "Cannot divide by zero", file main.cpp

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}

Our output log might now say something like this:

1Unhandled exception in cpp.exe

An error that is generated using the throw keyword is referred to as an exception. An unhandled exception (sometimes also called an uncaught exception) is simply an exception that our code hasn't detected and recovered from. We cover how to detect (or catch) exceptions later in this section.

Unreachable Code and throw

When a throw expression is encountered, the flow of our application is disrupted in a similar way to when a function encounters a return statement.

The main effect of this is that we can have unreachable code.

This is demonstrated in the following example, where our logging statement can never be executed:

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

In any function of our program, we can introduce code that can detect exceptions. The syntax is 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.

Below, we show a basic example of the syntax in action:

1#include <iostream>
2
3int main() {
4  try {
5    throw "Some Error";
6  } catch (...) {
7    std::cout << "I caught an error";
8  }
9
10  std::cout
11    << "\nThe program can continue as normal";
12}

Now, our throw statement doesn't immediately terminate our program. Instead, we execute the code within the catch block, and then our program continues as normal:

1I caught an error
2The program can continue as normal

More usefully, our try block will contain calls to other functions. If those calls result in a throw statement, the exception will bubble up the call stack until it finds a catch statement to handle it:

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  try {
10    Divide(5, 0);
11  } catch (...) {
12    std::cout << "I caught an error";
13  }
14
15  std::cout
16    << "\nThe program can continue as normal";
17}

1I caught an error
2The program can continue as normal

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

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  try {
10    Divide(5, 0);
11  } catch (...) {
12    std::cout << "I caught an error";
13    return -1;
14  }
15  std::cout << " but the program recovered";
16}

1I caught an error
2cpp.exe (process 34344) exited with code -1.

Because of the effect of throw on control flow, exceptions can be a common cause of memory leaks. This simple program has a memory leak if SomeFunction() can ever throw an exception:

1void MyFunction() {
2  int* MyInt { new int { 42 } };
3  SomeFunction();
4  // This may not be executed
5  delete MyInt;
6}

We could deal with this by wrapping our SomeFunction() call in a try-catch block. Alternatively, this is yet another scenario where using managed pointers can make our lives easier:

1#include <memory>
2
3void MyFunction() {
4  auto MyInt{std::make_unique<int>(42)};
5  SomeFunction();
6}

Within the above example, the ... syntax within catch (...) indicates we want this catch statement to catch all exceptions.

In more complex programs, this is generally not what we want - typically, our catch block will only want to catch the types of exceptions it can handle.

Specifying the type of exception we want to catch gives us the added benefit of being able to inspect the exception that was thrown like any other variable.

We can throw any type of object as an exception.

In this case, we threw a string - the literal expression: "Cannot divide by zero". As indicated in the output when we fail to catch this exception, this is an instance of const char*, ie, a C-style array of characters.

We cover char* in more detail later in the course but, for now, we can just consider it to be a type of string.

To catch exceptions of this specific type, we update our catch code to indicate it is only interested in const char* objects:

1try {
2  // ...
3} catch (const char*) {
4  // ...
5}

If we want to access the exception within our catch block, we simply give it a name and use it like any other variable:

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  try {
10    Divide(5, 0);
11  } catch (const char* e) {
12    std::cout << "I caught an error:\n";
13    std::cout << e;
14  }
15  std::cout << "\nRecovered Successfully";
16}

1I caught an error:
2Cannot divide by zero
3Recovered Successfully

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

1#include <iostream>
2
3int Divide(int x, int y) {
4  try {
5    if (y == 1) throw "Hi";
6    if (y == 2) throw -1;
7    if (y == 3) throw true;
8  } catch (const char* E) {
9    std::cout << "Caught a const char*: " << E;
10  } catch (int E) {
11    std::cout << "\nCaught an int: " << E;
12  } catch (...) {
13    std::cout << "\nCaught something else";
14  }
15  return x / y;
16}
17
18int main() {
19  Divide(5, 1);
20  Divide(5, 2);
21  Divide(5, 3);
22}

1Caught a const char*: Hi
2Caught an int: -1
3Caught something else

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.

Any other type will be caught by the catch(...) statement, including the bool thrown by the third call to Divide().

This pattern of having a final catch(...) block to capture anything that is not handled by more specific catch blocks is fairly common. Because of this, catch(...) is sometimes referred to as the default handler.

In this lesson, we've introduced the essence of exception handling in C++ using throw, try, and catch. The key points include:

• Understanding the use of throw to generate exceptions.
• Implementing try and catch blocks for catching and handling exceptions.
• Differentiating between catching specific exception types and using a catch-all handler.
• Practical application of multiple catch blocks to handle different types of exceptions.