C++ Crash Kurs. Exceptions. Dr. Dennis Pfisterer Institut für Telematik, Universität zu Lübeck

Transcription

1 C++ Crash Kurs Exceptions Dr. Dennis Pfisterer Institut für Telematik, Universität zu Lübeck

2 C++ Exceptions: Introduction What are exceptions Exceptions are error conditions in your code that require handling E.g., a file could not be opened, an action failed Why handle expections? It makes programs robust Traditional exceptions handling Traditionally, errors were handled where they occurred By evaluation return values or global error indicators (e.g., errno) 2

3 C++ Exceptions: Problems of traditional error handling Error conditions often remain unnoticed/unhandled No obligation to check error / not enforced by the compiler Many programmers tend to ignore return values Handling errors is complicated and tedious Example: Nobody checks printf s return value Problem is local error handling Errors must be handled in the current function Leads to code-bloat, makes code hard to read Mixes function and error-recovery code Often, errors can not be handled at the exact location 3

4 C++ Exceptions C++ uses Exceptions to handle error conditions Errors that can not be resolved locally, throw an exception Behaves like a super return until the exception is catched Delegates error handling to the place where it can be handled Example MyError is a normal C++ class throw leaves the current method jumps to the exception handler Exception-Handler may be far away from the throwing method class MyError const std::string data; public: MyError(const std::string msg = ) : data(msg) ; void f() throw MyError( Error description"); int main() f(); 4

5 C++ Exceptions: Catching exceptions If exceptions are to be catched, the code that produces exceptions is marked with try Following catch()-blocks catch exceptions of a certain type using normal polymorphism Example Function throwexception throws an exception of type int main catches and handles exceptions of type int try // Code throwing exceptions catch(type1 id1) // Handle exceptions of type type1 catch(typen idn) // Handle exceptions of type typen void throwexception() throw 42; int main() try throwexception(); catch(int code) cout << Error # << code << endl; 5

6 C++ Exceptions: Exception matching For an exception, the best handler is used using standard polymorphism Any derived exception matches catch(baseexception& b) First match is used, put more specialized handlers first No type conversions using constructors, etc. are performed Be aware of object slicing Slicing happens when a handler expects an object and not a reference or pointer Only a copy of the exception of the expected type is used Catch exceptions by reference (e.g., catch(baseexception& e) This allows dynamic_cast<derivedexception*> (&e) to work class Except1 ; class Except2 public: Except2(const Except1&) ; void f() throw Except1(); int main() try f(); catch(except2&) cout << Inside catch(except2)" << endl; catch(except1&) cout << Inside catch(except1)" << endl; 6

7 C++ Exceptions: Re-throwing an exception Sometimes errors can only be partially handled or resources must be freed Exceptions can be first catched and then be thrown again Example try catch(someexception& e) cout << "an exception was thrown" << endl; //Free ressources here throw; 7

8 C++ Exceptions: Catch any exception Sometimes, the type of the exception is of no interest It may be necessary to catch any exception that occurs Solution Uses C s ellipsis syntax (no parameter passed) catch(...) cout << An exception was thrown" << endl; Good Practice: Use this handler as the last one Often used to free memory or other resources and to pass on the exception catch(...) //Free resources here throw; //Rethrow the exception 8

9 C++ Exceptions: Unhandled Exceptions What happens when no catch-block is available Special method terminate() is called Standard implementation calls abort() abort() stops the program immediately No destructors called set_terminate( ) installs own handler and returns the previous Example #include <exception> #include <iostream> void terminator() cout << "I'll be back!" << endl; exit(0); void f() throw 42; int main(int arg, char** argv) set_terminate(terminator); f(); 9

10 C++ Exceptions: STL standard exceptions The STL defines some standard exception types Defined in #include <stdexcept> Can be used to indicate error conditions Can be sub-classed to add additional information on the error Example #include <stdexcept> using namespace std; class MyError : public runtime_error public: MyError(const string msg = "") : runtime_error(msg) ; int main() try throw MyError("my message"); catch(myerror& x) cout << x.what() << endl; 10

11 C++ Exceptions: STL standard exceptions Three fundamental exception types exception logic_error runtime_error The base class for all the exceptions thrown by the C++ Standard library. You can ask what( ) and retrieve the optional string with which the exception was initialized. Derived from exception. Reports program logic errors, which could presumably be detected by inspection. Derived from exception. Reports runtime errors, which can presumably be detected only when the program executes. and sub-classes of them Derived from logic_error domain_error invalid_argument length_error out_of_range bad_cast bad_typeid Reports violations of a precondition. Indicates an invalid argument to the function from which it is thrown. Indicates an attempt to produce an object whose length is greater than or equal to npos (the largest representable value of context s size type, usually std::size_t). Reports an out-of-range argument. Thrown for executing an invalid dynamic_cast expression in runtime type identification (see Chapter 8). Reports a null pointer p in an expression typeid(*p). (Again, a runtime type identification feature in Chapter 8). Derived from runtime_error range_error overflow_error bad_alloc Reports violation of a postcondition. Reports an arithmetic overflow. Reports a failure to allocate storage. 11

12 C++ Exceptions: Exception specification How do we know, which method throws which exceptions? Methods are not required to indicate the exceptions they throw C++ offers a syntax to indicate the exceptions thrown Three possibilities 1. Indicate the exceptions void f() throw(toobig, toosmall, divzero); 2. No indication ( any exception can be thrown) void f(); 3. No exception is thrown void f() throw(); Good practice: Use 1 or 3 12

13 C++ Exceptions: Exception specification Methods can throw exceptions they didn t declare (or may have called methods that didn t indicate which ones they throw) Similar to terminate(), unexpected is called Default implementation calls the terminate handler set_unexpected sets a new handler and returns the previous Example void f() throw 42; void g() throws() f(); void my_unexpected() cout << "unexpected exception thrown" << endl; exit(0); int main(int argc, char** argv) set_unexpected(my_unexpected); g(); 13

14 C++ Exceptions: When to use exceptions? Don t use exceptions Good-natured errors (enough local information to resolve the error) As a replacement for program flow instructions Use exceptions To resolve the error and re-invoke the method To do local error-recovery and pass-on the exception Wrap existing C code (throw exceptions instead of letting users check return values) Ease error-handling in general To make programs safer Eases debugging Makes programs more stable and forgiving to errors 14