CS11 Advanced C++ Fall Lecture 3

Size: px

Start display at page:

Download "CS11 Advanced C++ Fall Lecture 3"

Colin Edward Malone
5 years ago
Views:

1 CS11 Advanced C++ Fall Lecture 3

2 Today s Topics C++ Standard Exceptions Exception Cleanup Fun with Exceptions Exception Specifications

3 C++ Exceptions Exceptions are nice for reporting many errors Code throwing the exception can detect the problem, but doesn t know how to handle it. Code that catches the exception knows what to do about the problem. With careful implementation of constructors and destructors, resources get cleaned up, too. C++ Standard Library provides a number of standard exception classes

4 Simple Example void calculate(int x) { if (x < 0) throw domain_error("x is negative"); // Do our calculation. int main() { try { calculate(-4.5); catch (domain_error) { cout << "Caught a domain error!" << endl;

5 What Happened? void calculate(int x) { if (x < 0) throw domain_error("x is negative"); // Do our calculation. C++ Standard Exceptions provide a what() function to retrieve error details. int main() { try { calculate(-4.5); catch (domain_error de) { cout << "Caught a domain error!" << endl; cout << de.what() << endl;

6 C++ Standard Exceptions Thrown by the C++ language exception #include <exception> bad_alloc #include <new> bad_exception #include <exception> bad_cast #include <typeinfo> bad_typeid #include <typeinfo> ios_base::failure #include <ios> logic_error #include <stdexcept> length_error #include <stdexcept> domain_error #include <stdexcept> out_of_range #include <stdexcept> invalid_argument #include <stdexcept> runtime_error #include <stdexcept> range_error #include <stdexcept> overflow_error #include <stdexcept> underflow_error #include <stdexcept>

7 Standard Exception Hierarchy Two major kinds of standard exceptions logic_error Intended for preventable errors, a.k.a. bugs Invalid function arguments, violated invariants, etc. A potential alternative to using assert() Steer clear of these for reporting runtime errors! runtime_error All other errors. Errors that can only be caught as the program executes

8 Using the Standard Exceptions These are available for use in your programs. Use them as-is, subclass them, or ignore them and make your own! I generally don t use them. You will probably have to handle them, at least Some people view this as a useful framework for all errors and exceptions; I don t. - Bjarne Stroustrup The C++ Programming Language 14.10

9 Local Variables and Destructors Normally, destructors are called when variables go out of scope void myfunction() { Class1 var1; Class2 var2("out.txt"); var1.dostuff(var2); Compiler adds: var2.~class2(); var1.~class1(); Compiler inserts destructor calls into the appropriate places Your code doesn t manually call destructors, ever.

10 Destructors and Exceptions void myfunction() { Class1 var1; Class2 var2("out.txt"); var1.dostuff(var2); var2.~class2(); var1.~class1(); THROW! propagate exception cleanup (stack unwinding) What happens if var2 constructor throws? Only var1 was constructed, so only var1 destructor gets called

11 Destructors and Exceptions (2) void myfunction() { Class1 var1; THROW! Class2 var2("out.txt"); no cleanup needed var1.dostuff(var2); var2.~class2(); var1.~class1(); propagate exception What happens if var1 constructor throws? Nothing was constructed, so no destructors get called

12 Destructors and Exceptions (3) void myfunction() { Class1 var1; Class2 var2("out.txt"); var1.dostuff(var2); var2.~class2(); var1.~class1(); THROW! cleanup (stack unwinding) propagate exception What happens if var1.dostuff(var2) throws? Both var1 and var2 were constructed, so both destructors get called (in reverse order of construction)

13 Classes and Exceptions Similar model used when constructors throw class Logger { LogConfig config; RotatingFile outputfile; public: Logger(const string &configfile) { // initialize logger ; THROW! What happens if the constructor body throws? The new Logger instance failed to be constructed config and outputfile have already been initialized, so their destructors are automatically called

14 Classes and Exceptions (2) Member initialization might also throw class Logger { LogConfig config; RotatingFile outputfile; public: Logger(const string &configfile) : config(configfile), outputfile(config) { ; // initialize logger THROW! What happens if outputfile constructor throws? The new Logger instance failed to be constructed (again) config was already initialized, so its destructor gets called

15 Classes and Exceptions (3) Another member constructor throws class Logger { LogConfig config; RotatingFile outputfile; public: Logger(const string &configfile) : config(configfile), outputfile(config) THROW! { ; // initialize logger What happens if config constructor throws? The new Logger instance failed to be constructed (yet again) nothing was initialized, so no member destructors are called

16 Fun with Exceptions

17 How Many Copies? class Widget {; void throwmeawidget(int id) { Widget w(id); throw w; // Huck this widget! try { throwmeawidget(23); catch (Widget mywidget) { How many times is the Widget copied? throw always copies what is thrown into a temporary variable which is then copied into mywidget in the catch block.

18 How Many Copies? (comments) Two copies are made in this example. Avoid the second copy by catching a reference to the exception. try { throwmeawidget(23); catch (Widget &mywidget) {

19 What Did I Throw?? class Widget {; class SpecialWidget : public Widget {; void throwmeawidget(int id) { SpecialWidget sw(id); Widget &wref = sw; // refers to a SpecialWidget throw wref; What gets thrown? throw always copies what is thrown using the static type of the expression that is thrown! Our Widget isn t so special anymore! (Unless Widget has a virtual copy-constructor )

20 What Did I Catch?? class Widget {; class SpecialWidget : Widget {; void throwmeawidget(int id) { SpecialWidget sw(id); throw sw; try { throwmeawidget(59); catch (Widget mywidget) { What gets caught? (This should be easy by now )

21 What Did I Catch?? (comments) A Widget is caught. Any data-members in SpecialWidget are lost! This is called the slicing problem, or just slicing Widget s copy-constructor knows nothing about SpecialWidget s data members. Avoid this by catching a reference (again) try { throwmeawidget(59); catch (Widget &mywidget) { // Our Widget is still special!

22 Becoming Part of the Problem void throwmeawidget(int id) { SpecialWidget sw(id); throw sw; try { throwmeawidget(59); catch (Widget &w) { throw w; // Propagate the exception What gets propagated? throw always copies what is thrown Oops our Widget isn t special again. And we incur an extra copy! (Insult to injury!)

23 Another Variant void throwmeawidget(int id) { SpecialWidget sw(id); throw sw; try { throwmeawidget(59); catch (Widget &w) { throw; // Propagate the exception Now what gets propagated? throw always copies what is thrown except in this case! This rethrows what was caught. Now we re good. No slicing, no extra copying

24 The Morals Throw exactly what you intend to throw throw uses the static type of what is thrown throw makes a copy of what is thrown Catch a reference to what is thrown Avoids extra copying overhead Avoids slicing what is thrown down to the base-class Be careful to rethrow what was caught Use throw; by itself, without specifying anything.

25 Exception Specifications C++ functions can state what they throw. void f(int a) throw (E); f throws only E E is a type name (class, primitive, etc.) void g(int a) throw (E1, E2); g throws only E1 or E2 void h(int a) throw (); h does not throw any exception

26 Exception Specifications (2) When a function has no exception specification, C++ assumes it can throw anything int f(); // Could throw anything! Declaration and definition must specify the exact same exceptions int g() throw (E1, E2); int g() throw (E1) { COMPILE ERROR

27 Inheritance and Exception Specifications A derived class version of a function must have an exception specification at least as restrictive as the base class specification class Base { public: virtual void f(); // Can throw anything virtual void g() throw (X, Y); virtual void h() throw (X); ; class Derived : public Base { public: void f() throw (X); // OK void g() throw (X); // OK void h() throw (X, Y); // ERROR! ;

28 Violating Exception Specifications Exception specifications can be dangerous void f1(int x); void f2(int x) throw (E) { f1(x); This is allowed, even though f1 can throw anything! If f1 throws something other than E, an unexpectedexception handler is called Default unexpected-exception handler will simply terminate the program Usually not what you wanted to happen

29 Throwing Bad Exceptions Can improve the situation a bit void f1(int x); void f2(int x) throw (E, std::bad_exception) { f1(x); Now if f1 throws something other than E, then bad_exception will be thrown instead.

30 Customizing Bad-Exception Handling When an unexpected exception is thrown, std::unexpected() function is called This is what tries to throw bad_exception, or calls terminate() instead. Can replace default handler with your own typedef void (*unexpected_handler) (); unexpected_handler set_unexpected(unexpected_handler); <exception> header, std namespace Can also replace std::terminate(), etc. Must do these things correctly! Typically avoided.

31 Exception Specifications and Templates Want a generic == template for objects template<class T> bool operator==(const T& lhs, const T&rhs) throw () { return &lhs == &rhs; Function-template that says two objects are equal if their addresses are the same. Is the throw () specification safe?

32 Exception Specifications and Templates Is the throw () specification safe? template<class T> bool operator==(const T& lhs, const T&rhs) throw () { return &lhs == &rhs; Same as: operator==(lhs.operator&(), rhs.operator&()) T may have overloaded operator& to throw! Have no guarantees on what T might throw Back to unexpected() land

33 Exception Specification Guidelines Avoid exception specifications on templates Don t know exception-throwing behaviors of type parameters Similar issues with function pointers and exception specifications Be aware of what happens when unexpected exceptions are thrown Take appropriate steps if default behaviors are unacceptable! Probably best place to use throw () is on your destructors Destructors shouldn t throw exceptions, ever.

34 Helpful Resources More Effective C++ Scott Myers Item 13: Catch exceptions by reference. Item 14: Use exception specifications judiciously. The C++ Programming Language Bjarne Stroustrup

35 This Week s Assignment Update the web-log processor to cleanly handle bad rows of data Invalid rows should cause parsing code to throw an exception Main logic can catch these exceptions, and gracefully handle the parsing error Keep track of bad row count Allow user to specify an upper limit of bad rows Dump bad row data to cerr, or a separate file

void fun() C::C() // ctor try try try : member( ) catch (const E& e) { catch (const E& e) { catch (const E& e) {

void fun() C::C() // ctor try try try : member( ) catch (const E& e) { catch (const E& e) { catch (const E& e) { TDDD38 APiC++ Exception Handling 134 Exception handling provides a way to transfer control and information from a point in the execution to an exception handler a handler can be invoked by a throw expression