Assertions and Exceptions

Size: px

Start display at page:

Download "Assertions and Exceptions"

Rosalyn Arnold
5 years ago
Views:

1 CS 247: Software Engineering Principles Assertions and Exceptions Reading: Eckel, Vol. 2 Ch. 1 Exception Handling U Waterloo CS247 (Spring 2017) p.1/32

2 Defensive Programming The question isn t whether or not we will make programming errors... the question is whether or not we will arrange for our compiler and tools to help us find them. Sutter & Alexandrescu, C++ Coding Standards U Waterloo CS247 (Spring 2017) p.2/32

3 Possible Failures Errors in your code bugs, invariant violation, exposure of data representation Misuse of your code client-code violations of your preconditions External problems non existent input file, inappropriate file permissions out of memory, memory corruption hardware limitations (overflow, underflow) U Waterloo CS247 (Spring 2017) p.3/32

4 Assertions Use assertions to document and check assumptions. Check preconditions of functions. Check postconditions of functions. Check representation invariants (next week s lectures). Check postconditions of called functions. Goal: Abort program as close to error as possible, then can use debugger to examine program state. U Waterloo CS247 (Spring 2017) p.4/32

5 Assertions in Production Code? It depends: Yes: don t want to risk the program corrupting persistent data. No: may need program to keep executing; maybe bug doesn t have that many bad consequences. Can remove all assertions by compiling with preprocessor variable NDEBUG defined: % g++ -DNDEBUG... Warning: Assertions should not have side effects! assert ( i++ == 10); // program behaves differently if asserts are defined U Waterloo CS247 (Spring 2017) p.5/32

6 Error Recovery calls calls calls calls main() f1() f2() fn() and recover from more here returns can recover from some problems here returns something bad happens here Goal: pass information from the point where an error is detected to a point where it can be handled. U Waterloo CS247 (Spring 2017) p.6/32

7 Traditional Error Handling Techniques ifstream infile; // ifstream used to read from file infile.open("data"); // opens file "data" on disk if (!infile) { cout << "Error opening input file data." << endl; exit(1); while (!infile.eof()) { true String name; infile >> name; if (infile.fail()) { // react to read failure (likely format error) else if (infile.bad()) { // react to read failure (likely some data lost) else { // process data U Waterloo CS247 (Spring 2017) p.7/32

8 Exceptions An exception is an object thrown to represent the occurrence of an error. Passes information from the point where an error is detected to a point where it can be handled. Called component reports failure by throwing an exception. Caller component specifies which kinds of failures it can handle in catch-clauses of a try-block. Example: RationalExceptional.cpp U Waterloo CS247 (Spring 2017) p.8/32

9 void f() { // some code C++ Exception Handling Supposedly Risk-free Code try { Risky Codecould throw exceptions catch (type1& e1) { catch (type2& e2) { Error-handling code catch (type3& e3) { // more code Eckel and Allison, Thinking in C++ Vol. 2 Supposedly Risk-free Code U Waterloo CS247 (Spring 2017) p.9/32

10 class Rational { public: class DivideByZeroException {; Rational( int, int ); ; Rational::Rational(int numer, int denom) { if (denom == 0) { // throw 0; // throw "Denominator cannot be 0."; throw DivideByZeroException; Throwing an Exception reduce( numer, denom ); numerator_ = numer; denominator_ = denom; Can throw values of any type that can be copied Can throw error messages Usually throw userdefined object U Waterloo CS247 (Spring 2017) p.10/32

11 Exception Class class Rational { public: class DivideByZeroException { public: DivideByZeroException( int n ) : numer_(n) { int numer() const { return numer_; // accessor private: int numer_; // exception data ;... ; Rational::Rational(int numer, int denom) { if (denom == 0) { throw DivideByZeroException( numer );... U Waterloo CS247 (Spring 2017) p.11/32

12 Standard Exceptions Programmers can define their own exception hierarchy, or derive new exceptions from the standard exception hierarchy. #include<exception> exception logic_error bad_alloc #include<new> bad_exception #include<exception> domain_error invalid_argument bad_typeid bad_cast runtime_error #include<typeinfo> #include<typeinfo> length_error out_of_range underflow_error overflow_error #include<stdexcept> range_error U Waterloo CS247 (Spring 2017) p.12/32

13 Catching an Exception int main () { Rational r; try { cout << "Enter rational number (a/b): "; cin >> r; // can throw exception catch ( Rational::DivideByZeroException &e ) { cout << e.numer() << "/0 is not a legal Rational value." << endl;... U Waterloo CS247 (Spring 2017) p.13/32

14 Catching an Exception Exception is handled by the "nearest" handler whose argument matches the type of the exception object. in the same routine as it is thrown in the (dynamically) nearest client-code routine that has a matching catch-clause whose try-block encloses the throw. If there is no matching handler, then the program aborts. U Waterloo CS247 (Spring 2017) p.14/32

15 Stack Unwinding As control transfers to an exception handler, it must pop off the call stack all of the scope blocks that reside on top of the matching handler. Objects in the stack are deleted for us automatically, invoking the appropriate destructors. Partially constructed stack-based objects (e.g., objects from failed constructors) are properly destroyed. If, during stack unwinding, a destructor throws an exception that it does not handle locally, the program terminates. What about heap-based objects? U Waterloo CS247 (Spring 2017) p.15/32

16 Matching, Throwing, Rethrowing class X { public: class Trouble {; class Small : public Trouble {; class Big : public Trouble {; void f() { throw Big(); ; Never reached -- Trouble clause will catch Big exceptions int main() { X x; try { x.f(); catch(x::small&) { base-class handler catches derived-class exceptions a catch-any handler cout << "Small Trouble"; throw Trouble(); rethrows same catch(x::trouble&) { exception object cout << "Trouble"; catch(x::big&) { cout << "Big Trouble"; catch(...) { cout << "catches any type of exception"; throw; Eckel and Allison, Thinking in C++ Vol. 2 U Waterloo CS247 (Spring 2017) p.16/32

17 What about the Heap-Based Objects? Using normal pointers: if (somecondition) { MyClass* rc = new MyClass (); // do Stuff delete rc; If "do Stuff" throws an exception or returns normally, then delete rc is never executed, even if the system manages to recover from the exception. U Waterloo CS247 (Spring 2017) p.17/32

18 Exception Safety Guarantees An operation is exception-safe if it leaves the program in a valid state after terminating by throwing an exception, e.g. basic guarantee: basic invariants of all objects are maintained, and no resources, such as memory, are leaked strong guarantee: basic guarantee + state of the program reverts to what it was prior to the call nothrow guarantee: basic guarantee + guarantee not to throw an exception U Waterloo CS247 (Spring 2017) p.18/32

19 Smart Pointers Raw pointers in C++ are basically addresses of data with a bit more type safety than C pointers. However, it s legal and common to accidentally: access an object that s been deleted delete an object that s already been deleted delete an object that another pointer refers to You would like your pointers to be smart enough to do the correct and obvious thing with respect to object deletion. Example: RationalUniquePtr.cpp U Waterloo CS247 (Spring 2017) p.19/32

20 Smart Pointers A smart pointer, such as unique_ptr< >, is actually a templated object with an internal pointer variable that points to a heap object. the class overloads the * and -> operators, so it feels like a real pointer instances are typically created as stack-based objects heap object usually allocated in constructor destructor deletes the heap object it points to so if an exception is raised, then the smart pointer s destructor is invoked, which in turn deletes the heap-based object it points to U Waterloo CS247 (Spring 2017) p.20/32

21 Using smart pointers Using Smart Pointers if (somecondition) { unique_ptr<myclass> rc ( new MyClass () ); // do Stuff If "do Stuff" throws an exception or returns normally, then the object rc (and the Circle object that it points to) is deleted automatically during stack unwinding; otherwise, rc is destroyed at the end of its enclosing block just like any other stack-based object. U Waterloo CS247 (Spring 2017) p.21/32

22 unique_ptr #include <memory> A unique_ptr supports exclusive ownership of a referent should be the sole pointer to its referent a unique_ptr cannot be copied (however, it can be moved) is responsible for destroying its referent Stroustrup, The C++ Programmng Language, 4ed U Waterloo CS247 (Spring 2017) p.22/32

23 unique_ptr template <class X> // partial, simplified definition class unique_ptr { public: typedef X element_type; // holds smart pointer to X // construct/copy/destroy: explicit unique_ptr( X* p =0 ); // creates unique_ptr bound to *p ~unique_ptr(); // delete object unique_ptr( unique_ptr&& ); // transfers ownership unique_ptr& operator=( unique_ptr&& ); // transfers ownership unique_ptr& operator=( nullptr ); // delete object, set this to null // members: X& operator*() const; // access referent X* operator->() const; // access member of referent X* get() const; // returns pointer X* release(); // unbinds: returns ptr, set this to null void reset(x *p =0); // destroys old referent and binds this to *p ; U Waterloo CS247 (Spring 2017) p.23/32

24 Useful for Transferring Ownership unique_ptr<t> Source() { return unique_ptr<t> ( new T ); // return by copy unique_ptr<t> pt = Source(); void Sink ( unique_ptr<t> pt ) { // passed in by copy == transfer of ownership pt.reset(); Sink( pt ); U Waterloo CS247 (Spring 2017) p.24/32

25 shared_ptr #include <memory> A shared_ptr supports shared ownership of a referent referent maintains a count of pointers referring to it when count reaches 0, the object can be destroyed control block use count weak count deleter Stroustrup, The C++ Programmng Language, 4ed U Waterloo CS247 (Spring 2017) p.25/32

26 weak_ptr #include <memory> A weak_ptr works with a shared_ptr and shares ownership of a referent, but does not contribute to the reference count. can test if the object has been destroyed and weak_ptr is dangling auto spw = std::make_shared<widget>(); std::weak_ptr<widget> wpw (spw); spw = nullptr; if ( wpw.expired() ) but must convert into a shared_ptr in order to reference object auto spw2 = wpw.lock(); // if wpw's expired, spw1 is null std::shared_ptr<widget> spw3(wpw); // if wpw's expired, // throw std::bad_weak_ptr U Waterloo CS247 (Spring 2017) p.26/32

27 The RAII Programming Idiom Resource Acquisition is Initialization (RAII): equates resource management with the lifetime of an object. - Resource is allocated inside an object's constructor. - Resource is deallocated inside an object's destructor. class Resource { resource_type *r_; resource_type* allocate( parms p ); void release ( resource_type* ); public: Resource (parms p) : r_( allocate(p) ) { ~Resource() { release(r_); // accessors, mutators, etc. ; U Waterloo CS247 (Spring 2017) p.27/32

28 #include <cstdio> #include <stdexcept> // std::runtime_error class file { public: file(const char* filename) : file_(std::fopen(filename, "w+")) { if (!file_) { throw std::runtime_error("file open failure"); ~file() { if (std::fclose(file_)) { // failed to flush latest changes. // handle it void write(const char* str); RAII Example // prevent copying and assignment; not implemented file(const file &) = delete; file& operator=(const file &) = delete; private: std::file* file_; ; U Waterloo CS247 (Spring 2017) p.28/32

29 noexcept Functions may declare that they will not throw exceptions. class Rational { public: class DivideByZeroException {; Rational( int, int ); ~Rational() noexcept; int numer() const noexcept; ; Benefits the programmer, who doesn t have to provide try-clauses. Benefits the compiler, which can optimize for no exceptions. U Waterloo CS247 (Spring 2017) p.29/32

30 Exceptions vs. Assertions Do not use exceptions to report programming errors. Throwing an exception will unwind the program stack and destroy local variables. We want the program to terminate on the exact line where the violation occurred, with the whole program state intact for our examination. U Waterloo CS247 (Spring 2017) p.30/32

31 Summary When to use exceptions Not for programming errors (use assertions) Often not needed if simply terminating program - Can let system clean up Throw exceptions in constructor, mutators Don't throw exceptions in destructors, copy constructors, assignment, accessors, operators How to use exceptions Nest exception class declarations inside class descriptions Use class hierarchies (for polymorphic handlers) Catch exceptions by reference, not by value (polymorphism) Use RAII, smart pointers to perform automated cleanup Use noexcept (not exception specifications) U Waterloo CS247 (Spring 2017) p.31/32

32 What you should get from this Recognition Where and when to use (or not use) exceptions Motivation for RAII idiom Comprehension How exception handling works in C++, including rules for finding a matching handler and how stack unwinding works When to use exceptions vs. assertions, and why When to use unique_ptr vs. shared_ptr vs. weak_ptr Application Throw and catch exception objects Nest exception classes within ADT classes How to use smart pointers How to use RAII to ensure resource initialization and cleanup noexcept U Waterloo CS247 (Spring 2017) p.32/32

CS11 Advanced C++ Fall Lecture 3

CS11 Advanced C++ Fall Lecture 3 CS11 Advanced C++ Fall 2006-2007 Lecture 3 Today s Topics C++ Standard Exceptions Exception Cleanup Fun with Exceptions Exception Specifications C++ Exceptions Exceptions are nice for reporting many errors