C++ Exceptions

A failure that jumps to a handler

Some functions cannot do their job: divide by zero, a missing setting, a value outside the legal range. You can return a special code from every function on the path. Or you can throw an exception and let acatch block higher up handle it.

This chapter uses runtime_error from <stdexcept>. Include that header. Catch the standard base type with catch (const exception& e) so you can print e.what().

throw runtime_error

throw stops the current function. The object you throw travels up the call stack until a matchingcatch takes it. If nothing catches it, the program terminates.

#include <iostream>
#include <stdexcept>
using namespace std;

int divide(int a, int b) {
  if (b == 0) {
    throw runtime_error("divide by zero");
  }
  return a / b;
}

int main() {
  try {
    cout << divide(10, 2) << endl;
    cout << divide(10, 0) << endl;
  } catch (const exception& e) {
    cout << e.what() << endl;
  }
  return 0;
}

The first call prints 5. The second throws. main catches it and printsdivide by zero. The program still returns 0. Without try, that second call would abort.

try and catch

Put the risky work in try. Put recovery in catch. Execution enters the catch only if something was thrown. After the catch finishes, the function continues as normal.

#include <iostream>
#include <stdexcept>
using namespace std;

int main() {
  try {
    throw runtime_error("disk full");
  } catch (const exception& e) {
    cout << "recovered: " << e.what() << endl;
  }
  cout << "still running" << endl;
  return 0;
}

Output is two lines. The exception was not fatal. That is the difference from an uncaught error: you choose a message, a fallback value, or a clean exit.

catch (const exception&)

Catch by const reference. That avoids copying the exception object and lets derived types such asruntime_error and invalid_argument match the base exception.e.what() returns a C string that describes the failure.

Validate, then throw

A setter or a helper can throw when the caller passes a bad value. The caller wraps the call in try/catch instead of checking a magic return code after every line.

#include <iostream>
#include <stdexcept>
using namespace std;

int percent(int n) {
  if (n < 0 || n > 100) {
    throw runtime_error("percent out of range");
  }
  return n;
}

int main() {
  try {
    cout << percent(40) << endl;
    cout << percent(140) << endl;
  } catch (const exception& e) {
    cout << e.what() << endl;
  }
  return 0;
}

40 prints. 140 does not reach return n. The catch prints the message fromthrow.

When not to throw

• Do not throw for expected, everyday cases such as “the user typed a letter.” Ask again, or return a bool.
• Do not use exceptions as a second return value for success. They are for failures you cannot handle locally.
• Keep try blocks short so it is obvious which call can fail.