The Standard Exception Class Hierarchy

• There is a standard exception class hierarchy.
• See this reference
• #include<exception>
• In a hierarchy there is a base class.
  • In this case, that would be exception
  • Methods
    • Constructor, copy constructor
    • Destructor.
    • assignment operator
    • what
      • This is virtual, which means it can be replaced
      • It returns a string.
  • When throwing

    • throw exception(); 

    • This creates a new instance of the exception class.
  • When catching

    •     } catch (const exception &  e) {
               cout << "\t\tCaught " << e.what() << endl;

    • Notice the catch by constant reference.
    • This will be important later.
  • Look at case2.cpp
• logic_error
  • reference, look at UML diagram.
  • this is derived from exception
    • A logic_error is a exception.
  • Therefore it has all of the methods of that class.
  • But it has a different constructor
    • you must pass it a string.
  • It is used for errors that can only be detected at runtime for logical errors.
    • Index out of bounds for example.
  • This is also the parent of a hole family of classes.
  • you can catch a logic_error as an exception.
  • You can not catch an exception as a logic_error.
• There are a set of exceptions derived from logic_error
• There are several different classes of exceptions besides logic_error
• Catching exceptions
  • Always catch as const reference.
  • This avoids slicing
  • This will be discussed later.
• noexcept Function Specifier
  • Like const, this marks a function with certain properties.
  • In this case, it can not throw an exception.
  • If an exception occurs, the program terminates.
  • This is required to make the function polymorphic.
  • But fortunately c_str() is exception free.
• Extending the exception class
  • Hierarchies can be extended.
  • I have done this in case4.cpp
  • Don't worry about all of the syntax yet.
  • I did need to handle an exception problem in the constructor.