1. CSE 332: C++ Exceptions Motivation for C++ Exceptions Void Number:: operator/= (const double denom) { if (denom == 0.0) { // what to do here? } m_value /= denom; } Need to handle cases where program cannot behave normally –E.g., zero denominator for division Otherwise bad things happen –Program crashes –Wrong results Could set value to Number::NaN –I.e., a special “not-a-number” value –Must avoid using a valid return value… –… which can be difficult (e.g., for int) –Anyway, caller might fail to check for it Exceptions offer a better alternative

2. CSE 332: C++ Exceptions C++ Exception Syntax void foo() throw (int) { throw 2; } try { foo(); } catch (int &i) { cout << “caught ” << i << endl; } catch (...) { cout << “another exception” << endl; } Can throw any type A function’s declaration can list types it can throw –Otherwise the function may throw any defined type Can catch and inspect or use exceptions “Default” catch block is indicated by three dots –Catches every type

3. CSE 332: C++ Exceptions C++11 Exceptions C++11 standardizes a hierarchy of exception classes –To access these classes #include Two main kinds (subclasses) of exception –Run time errors (overflow errors and underflow errors) –Logic errors (invalid arguments, length error, out of range) Several other subclasses of exception –Bad memory allocation –Bad cast –Bad type id –Bad exception You can also declare other subclasses of these –Using the class and inheritance material in later lectures

4. CSE 332: C++ Exceptions Overview of C++ Exceptions Normal program control flow is halted –At the point where an exception is thrown The program call stack “unwinds” –Stack frame of each function in call chain “pops” –Variables in each popped frame are destroyed –This goes on until an enclosing try/catch scope is reached Control passes to first matching catch block –Can handle the exception and continue from there –Can free some resources and re-throw exception Let’s look at the call stack and how it behaves –Good way to explain how exceptions work (in some detail) –Also a good way to understand normal function behavior

5. CSE 332: C++ Exceptions A More Detailed Look at Stack Frames In general, the structure is common –A chunk of memory representing the state of an active function call –Pushed on program call stack at run-time g++ -s  generated machine code (in assembly language) –can be used to deduce exact structure for a given platform Each stack frame contains: –A pointer to the previous stack frame –The return address (i.e., just after point from which function was called) –The parameters passed to the function (if any) –Automatic (local) variables for the function Sometimes called “stack variables” previous frame pointer return address parameters automatic variables

6. CSE 332: C++ Exceptions Illustrating the Call Stack (1/8) int main (int argc, const char *argv[]) { Number n(8.1); try { n /= 0.0; cout << n << endl; } catch (int) { return 1; } return 0; } Stack frame for function main –Pushed on program call stack –With stack variable n –With parameters argc and argv Note that parameters are initialized at frame creation Variables are not necessarily initialized at frame creation –May occur later in called function argcargv n m_value main

7. CSE 332: C++ Exceptions Illustrating the Call Stack (2/8) int main (int argc, const char *argv[]) { Number n(8.1); try { n /= 0.0; cout << n << endl; } catch (int) { return 1; } return 0; } Number constructor called –Stack frame created argcargv n m_value main this Number::Number(const double n) n

8. CSE 332: C++ Exceptions Illustrating the Call Stack (3/8) Number::Number(const double n) :m_value(n) { } Enter Number constructor –m_value is set in object How do we know which m_value to set? –Implicit this pointer argcargv n m_value main this Number::Number(const double n) n

9. CSE 332: C++ Exceptions argcargv n m_value main Illustrating the Call Stack (4/8) Number::Number(const double n) :m_value(n) { } Return from constructor –Its stack frame is popped –Returns to main

10. CSE 332: C++ Exceptions Illustrating the Call Stack (5/8) int main (int argc, char **argv) { Number n(8.1); try { n /= 0.0; cout << n << endl; } catch (int) { return 1; } return 0; } Call operator/= on n –New stack frame created –Copy 0.0 into n –Set this argcargv n m_value main this Number::operator/=(const double denom) denom

11. CSE 332: C++ Exceptions Illustrating the Call Stack (6/8) Test denom against 0.0 –Test succeeds –throw integer 0 void Number::operator/=(const double denom) { if (denom == 0.0) { throw 0; } m_value /= denom; } argcargv n m_value main this Number::operator/=(const double denom) denom

12. CSE 332: C++ Exceptions argcargv n m_value main Illustrating the Call Stack (7/8) throw unwinds stack Skips over rest of function Returns to caller void Number::operator/=(const double denom) { if (denom == 0.0) { throw 0; } value_ /= denom; }

13. CSE 332: C++ Exceptions Illustrating the Call Stack (8/8) int main (int argc, char **argv) { Number n(8.1); try { n /= 0.0; cout << n << endl; } catch (int) { return 1; } return 0; } We’ve reached an enclosing try/catch scope –So stack unwinding stops Control jumps to first matching catch block –Skips over intervening cout statement (no output!) argcargv n m_value main

14. CSE 332: C++ Exceptions Catching Exceptions in C++ try { // can throw exceptions } catch (Derived &d) { // Do something } catch (Base &d) { // Do something else } catch (...) { // Catch everything else } Control jumps to first matching catch block Order matters if multiple possible matches –Especially with inheritance-related exception classes –Put more specific catch blocks before more general ones –Put catch blocks for more derived exception classes before catch blocks for their respective base classes

15. CSE 332: C++ Exceptions More About Catching Exceptions in C++ try { // can throw exceptions } catch (Derived &d) { // Do something } catch (Base &d) { // Do something else } catch (...) { // Catch everything else } catch(...) –Catches any type throw; –Throws nothing (cannot catch) –Often preferable to exit(1) –But usually it’s better to throw something E.g., a special type E.g., at least an int

16. CSE 332: C++ Exceptions Exception Specifications (do not use them) // can throw anything void Foo::baz(); // promises not to throw void Foo::baz() throw(); // promises to only throw int void Foo::baz() throw(int); // only char or int void Foo::baz() throw(char,int); Added in C++98, deprecated in C++11 Make promises to the calling function –Empty throw clause promises no exceptions –Can list multiple types (comma separated) By default, a function can throw whatever it wants –Throw clause in function signature limits what that function body can throw –But can call code that leaves off throw clause

17. CSE 332: C++ Exceptions Rules of Thumb for Using C++ Exceptions Use exceptions to handle any cases where the program cannot behave normally –Do not use exceptions as a way to control program execution under normal operating conditions Don't let a thrown exception propagate out of the main function uncaught –Instead, always catch any exceptions that propagate up –Then return a non-zero value to indicate program failure Don’t use or rely on exception specifications –A false promise if you declare them, unless you have fully checked all the code used to implement that interface –No guarantees that they will work for templates, because a template parameter could leave them off and then throw