Lecture 10: Error Handling

Suppose, we are implementing our own math library, and implemented the square root function like this (the implementation does not matter much to us):

double Sqrt(double a) {
  // 20 iterations are enough for doubles
  double x = 1;
  for (int i = 0; i < 20; ++i) {
    // x_{i+1} = x_i - f(x_i)/f'(x_i)
    //
    // where f(x) = x^2 - a, so the roots are +/- sqrt(a)
    //       f'(x) = 2x
    x = (x + (a / x) ) / 2;
  }
  return x;
}

Then, we can evaluate, say, Sqrt(4) and get 2. That looks sensible. However, the square root function is not defined for negative numbers. So, we need to report an error. The simplest option we have is to print an error and exit the program:

double Sqrt(double a) {
  if (a < 0) {
    std::cout << "tried to compute square root of negative number " << a << "\n";
    std::exit(1);
  }

  // 20 iterations are enough for doubles
  double x = 1;
  for (int i = 0; i < 20; ++i) {
    // x_{i+1} = x_i - f(x_i)/f'(x_i)
    //
    // where f(x) = x^2 - a, so the roots are +/- sqrt(a)
    //       f'(x) = 2x
    x = (x + (a / x) ) / 2;
  }
  return x;
}

So far, everything is nice. Our square root program always returns a correct value (or it does not return and stops the program). However, the programmer now needs to be careful when calling Sqrt: they also need to make the check the input every single time, or the program may randomly crash. Can we do better? More specifically, can we help the programmer by giving them a mechanism to handle the error of calling Sqrt with an invalid input. The answer is yes. Enter exceptions.

C++ has a construct called "exceptions" to handle, well, exceptional cases. You can read more about them at cppreference.com or in PS 16. Normally, a function runs and returns a value. However, when an exceptional case happens, the function may instead throw an exception, which means that the function stops executing and instead of returning a value, it passes an exception value to the caller (or whichever context is set up to catch that exception). For example, say we are trying to read a positive number from the input:

int main() {
    int value;
    try {
        cout << "Enter a positive number: ";
        cin >> value;

        if (value < 0)
            throw value;

        cout << "The number entered is: " << value << endl;
    } catch (int e) {
        cout << "The number entered is not positive:" << e << endl;
    }

    cout << "Statement after try/catch block" << endl;
    return 0;
}

Here, everything executes within the try block if execution is normal. Every try block must be accompanied by one or more catch blocks.

• Only when value < 0 would we throw something in the example above.
• Statements after throwing an exception within the try block is ignored, and code within the catch block of the exception type is executed. You can think of it as the execution "jumping" to the catch block.
• Regardless if an exception was thrown or not, execution resumes after the try/catch block.

Note that the value we caught in the catch statement is same as the value thrown by the throw statement. We can now change our square root function to throw an exception, so the caller can catch it:

double Sqrt(double a) {
  if (a < 0) {
    throw "passed negative value to sqrt";
  }

  // 20 iterations are enough for doubles
  double x = 1;
  for (int i = 0; i < 20; ++i) {
    // x_{i+1} = x_i - f(x_i)/f'(x_i)
    //
    // where f(x) = x^2 - a, so the roots are +/- sqrt(a)
    //       f'(x) = 2x
    x = (x + (a / x) ) / 2;
  }
  return x;
}

Now, the caller can catch the exception if they are not sure if the input is non-negative. They can also call Sqrt a bunch of times, and catch the first exception that would occur, like so:

try {
  Sqrt(2);
  Sqrt(-4);
  Sqrt(3);
  Sqrt(0);
  Sqrt(-3);
 } catch (const char * message) {
  cout << "caught error message: " << message << "\n";
}

Here, we are catching a const char * because Sqrt is throwing a string literal, which is of that type. This is inconvenient! Because, we cannot tell between other things that would throw an exception versus the things Sqrt throws. To solve this, we can define special classes so we can throw objects of those types:

struct SqrtError {};

// later, in Sqrt

double Sqrt(double a) {
  if (a < 0) {
    throw SqrtError{};
  }

  // ...
}

// now, we can catch only the errors from Sqrt (assuming nothing else throws
// SqrtError):

try {
  Sqrt(x);
 } catch (SqrtError& err) {
  cout << "passed negative value to sqrt, carrying on\n";
 }

Here, we are catching the exception by reference because exceptions are often in a class hierarchy with virtual methods.

An alternative to exceptions is returning the value in a wrapper that says "maybe there is a value". For example, we could define a class like this and return SqrtResult from Sqrt:

struct SqrtResult {
  bool is_valid;
  // valid only if is_valid is true
  double value;
};

Then, Sqrt can return a valid value only when the input is not negative:

SqrtResult Sqrt(double a) noexcept {
  if (a < 0) {
    // return an invalid value
    return SqrtResult(false, 0);
  }
  // 20 iterations are enough for doubles
  double x = 1;
  for (int i = 0; i < 20; ++i) {
    // x_{i+1} = x_i - f(x_i)/f'(x_i)
    //
    // where f(x) = x^2 - a, so the roots are +/- sqrt(a)
    //       f'(x) = 2x
    x = (x + (a / x) ) / 2;
  }
  return SqrtResult(true, x);
}

Callers of Sqrt would need to check the is_valid field before using the value now. Defining a result type for everything would be tedious, we can make SqrtResult generic to hold a value to get around that. Luckily, the standard library comes with a type like that: std::optional. std::optional works like this:

template<class T>
class optional {
  bool is_valid;
  T value;
public:
  T& operator * () { return value; }
  bool operator bool () { return is_valid; }
  // other stuff ...
};

So, if we have an optional value, we can check if it is valid like checking if a pointer is valid:

int * p = nullptr;
if (p) { // or p != nullptr
  // p evaluates to false, so we don't enter here
}

p = new int(5);

if (p) {
  // p evaluates to true, so we enter here
}

std::optional<int> o = std::nullopt;

if (o) { // or o != nullopt
  // o evaluates to false, so we don't enter here
}

o = 5; // note that we don't need new

if (o) {
  // o evaluates to true, so we enter here
}

We can also access the value inside, like a pointer:

optional<int> o = 42;
cout << *o << endl; // prints "42"

However, unlike a pointer, optionals carry the associated data with them (rather than pointing to them), so they destroy the value when they go out of scope.

Now, let's rewrite Sqrt using optional and use it in SolveQuadraticEqn:

// Compute square root using Newton's method
optional<double> Sqrt(double a) noexcept {
  if (a < 0) {
    return nullopt;
  }
  // 20 iterations are enough for doubles
  double x = 1;
  for (int i = 0; i < 20; ++i) {
    // x_{i+1} = x_i - f(x_i)/f'(x_i)
    //
    // where f(x) = x^2 - a, so the roots are +/- sqrt(a)
    //       f'(x) = 2x
    x = (x + (a / x) ) / 2;
  }
  return x;
}

// auto x = Sqrt(5); // x = double OR x = an error value

// Find the roots of given quadratic equation
pair<double, double> SolveQuadraticEqn(double a, double b, double c) {
  if (a == 0) {
    throw NonQuadraticEqn{};
  }
  // square root of discriminant

  if (optional<double> r = Sqrt(b * b - 4 * a * c)) {
    double d = r.value(); // we can also use *r
    return { (-b + d) / (2 * a), (-b - d) / (2 * a) };
  } else {
    throw NoRoots{};
  }
}

I used r.value() above, which throws an exception if r is empty (that is, it is equal to nullopt. We could've used *r instead in this case. If r is empty, then *r is undefined behavior.

Also, if you are not familiar with the way I wrote the second conditional there, if (optional<double> r = Sqrt(b * b - 4 * a * c)) is roughly same as:

optional<double> r = Sqrt(b * b - 4 * a * c);
if (r)

So, the guard of if uses the assigned value r. The benefit of that if statement is that r is not available in the else block because it is restricted to only the true branch. This allows us to use the compiler to get an error if we mistakenly use r in the false branch.