https://www.youtube.com/watch?v=_Ivd3qzgT7U

Basics

use throw keyword to signal errors

// throw <value of any data type!>;
throw 1;
throw "error";

use try catch to handle exceptions.

C++ tries to find catch block recursively. if none are found, program terminates with runtime exception.

try {
  // do something..
} catch (arg1) {
  // catch arg work like function args
  
  // basic types (like int, etc.) can be caught by value
  // non-basic types (classes) should be caught by const ref
  // to avoid unneeded copy or slicing!
  
  // no type conversion is done for exceptions!
  // e.g. int will not be matched with double catch block!
  
  // but casts from a derived to parent class will be performed!
} catch (arg2) {
} catch (...) {
  // catch has exactly 1 arg or "..." (catch all exceptions!)
}

Exceptions can be rethrown in the catch block, but it rethrowned exception is caught by parent try block…

try {
  ...
} catch ([some exception]) {
  // throw; -> throw the same exception again
  // throw [obj];  -> throw a new exception
}

With class member functions

exceptions thrown in normal member functions behave as usual

exceptions thrown in constructors will not trigger destructors of the class itself! however, destructors of class member variables are triggered!

Stack unwinding

• The matching catch block and the thrown exception may not be in the same function. During runtime, the program will unwind the stack as many times as needed to make the function with the matching catch block on top of the stack.
• If the function is unwound, the stack frame is removed, local variables are destroyed as usual, but no value is returned.
  • Destructors are called during unwinding. If exceptions are thrown in destructors here, the runtime doesn’t know how to handle! → this triggers std::terminate() immediately!
  • Destructors are marked noexcept implicitly!
• If an exception is not caught, the stack may or may not be unwound. We may not want to unwind in such cases is to preserve the stack trace and local variable info, which might be useful for debug!

Exception object

• exception header defined std::exception, while stdexcept defined some commonly used exception classes derived from std::exception, e.g. std::runtime_error, std::invalid_argument, …
• Exception objects are put in a separate memory space dedicated for exception handling, not in the stack → can survive stack unwind.
  • Their lifetime is until the exception caught and catch block finishes.