Exception Handling

int milk, donuts;
cin << milk << donuts;

double dpg = donuts / static_cast<double>(milk);
cout << dpg;

Try-Catch

try {
  int milk, donuts;
  cin << milk << donuts;

  if (milk <= 0) throw donuts;

  double dpg = donuts / static_cast<double>(milk);
  cout << dpg;
} catch(int e) {
  cout << "We have " << e << " donuts, and no milk!" << endl;
}

Try Block

Catch Block

Nested Try-Catch Blocks

Defining Your Own Exception Class

class NoMilk {
public:
  NoMilk(){}
  NoMilk(int num) : count(num) {}
  int getCount() const {return count;}
private:
  int count;
}
int main () {
  try {
    int milk, donuts;
    cin << milk << donuts;

    if (milk <= 0) throw NoMilk(donuts);

    double dpg = donuts / static_cast<double>(milk);
    cout << dpg;
  } catch(NoMilk e) {
    cout << "We have " << e.getCount() << " donuts, and no milk!" << endl;
  }
}

Trivial Exception Class

Multiple Throws And Catches

try {
  int milk, donuts;
  cin << milk << donuts;

  if (milk < 0) throw NegativeNumber("milk");
  if (milk == 0) throw DivideByZero();

  double dpg = donuts / static_cast<double>(milk);
  cout << dpg;
} catch(NegativeNumber e) {
  cout << "Cannot have a negative number of " << e.getMessage() << endl;
} catch (DivideByZero) {  // no need to give parameter if not used
  cout << "ERROR: DIVIDE BY ZERO!";
}

Throwing Exceptions In Functions

try {
  quotient = safeDivide(num, denom);
} catch(DivideByZero) {
  cout << "ERROR: DIVSION BY ZERO!";
}
// Function throws to outer try-catch block
double safeDivide(int top, int bot) throw (DivideByZero) {
  if (bottom == 0) throw DivideByZero();
  return top / static_cast (bottom);
}

Exception Specification

In Practice

• Run-time checking:
  • exception specifications are checked at runtime rather than at compile time. Does not guarantee that all exceptions have been handled.
  • unhandled exceptions call std::unexpected() which defaults to terminating the program.
• Run-time overhead:
  • Run-time checking requires the compiler to produce additional code. Affects optimizations.
• Unusable in generic code:
  • not generally possible to know what types of exceptions may be thrown, so a precise exception specification cannot be written.

1. might throw any exception: omit exception-specification
2. will never throw any exception: noexcept (see below)

Inheritance

Programming Techniques For Exception Handling

1. Separate throwing and catching into separate functions - throw within a function definition and list it in the exception specification, but place the catch clause in a different function
2. Never let the destructor throw an exception as it might be called when dealing with another exception
3. Exceptions should be used sparingly as they alter the flow of control. As a good rule of thumb, if a throw is desired, consider how to do it without the throw and if reasonable, do that instead.

4 Levels of Exception Safety

1. No Guarantee
   • If an exception occurs, it will not be handled
   • Memory can be leaked
   • Class invariants can be violated

   class A {
     int *i;
     A(int *i) : i { i } {}
     ~A() { delete i; }
   }
   

   If an error occurs and an exception is thrown with an object of type A, the destructor will not be called and there will be a memory leak. This does no have any exception handling thus it has no guarantee.
2. Basic Guarantee
   • If an exception occurs, the program is valid, but in an unspecified state
   • Nothing is leaked
   • Class invariants are maintained
   • e.g. Regular copy constructor where data is lost
   e.g.

   class A {}
   class B {}
   class C {
     A a;
     B b;
   public:
     void f() {
       a.method1();
       b.method2();
     }
   };

   If a.method1() runs and b.method2() has an error, the state of a is changed without b changing. This results in a partial function.
   
3. Strong Guarantee
   • Exception is raised while executing error
   • The state of the program will be as if the function had not been called
   • e.g. Copy and Swap idiom
e.g.

class C {
  A a;
  B b;
public:
  void f() {
    A aTemp = a;  // calls copy ctor
    B bTemp = b;
    aTemp.method1();
    bTemp.method2();
    std::swap(a, aTemp);  // nothrow
    std::swap(b, bTemp);  // nothrow
  }
}

If we had used a copy assignment operator instead of swap, we would not have a strong exception guarantee because copy assignment operator could throw. The non-throwing swap ensures that the state of a and b are not changed if the above methods fail.

4. Nothrow Guarantee
   • Function will never throw an exception
   • no exception is emitted outside of the function
   • Always accomplishes its task
   • use noexcept
A possible further enhancement to the above example with strong guarantee is to use pointers via the pImpl idiom as copying pointers cannot throw exceptions. This provides a nothrow guarantee. i.e.

struct Cimpl {
 A a;
 B b;
}
class C {
 unique_ptr pImpl;  // pointer to implementation
public:
 auto temp = make_unique(*pImpl);
 // if temp == nullptr, nothing happens
 temp->a.method1();
 temp->b.method2();
 std::swap(pImpl, temp);
};  // Nothrow

STL Vectors

Emplace Back

1. allocates a new, larger array
2. copy the objects over via copy constructor
3. If copy constructor throws:
   1. destroys new array
   2. old array is intact
   3. strong guarantee
4. else delete old array

1. allocate new larger array
2. move the objects over
3. delete old array

class MyClass {
public:
  MyClass(MyClass &&other) noexcept {}
  MyClass &operator=(MyClass &&other) noexcept {}
}