05-01 Discussion Notes

Transcription

1 05-01 Discussion Notes PIC 10B Spring Exceptions 1.1 Introduction Exceptions are used to signify that a function is being used incorrectly. Once an exception is thrown, it is up to the programmer to decide how the exception is handled. Consider the following 1 int f a c t o r i a l ( double n ) { 2 int m = 1 ; 3 for ( int i = 2 ; i <= n ; ++i ) { 4 m = i ; 5 } 6 return m; This function calculates n!, which is only defined for integers n 0. The question then arises: what should happen when the programmer attempts to call the factorial of a negative number or a non-integer? In these cases, we should throw an exception: 1 2 int f a c t o r i a l ( double n ) { 3 i f ( static cast <int >(n )!= n ) { 4 throw std : : i n v a l i d a r g u m e n t ( non i n t e g e r ) ; 5 } else i f ( n < 0) { 6 throw std : : i n v a l i d a r g u m e n t ( n e g a t i v e number ) ; 8 int m = 1 ; 9 for ( int i = 2 ; i <= n ; ++i ) { 10 m = i ; 12 return m; 14 int main ( ) { 15 f a c t o r i a l ( 5); 16 std : : cout << Does not p r i n t << std : : endl ; 1 Above, we throw an std::invalid argument object, passing in an error message to its constructor, when the user misuses the function. If one of the throw commands is reached in the code, the function will immediately unwind so that the code beginning at int m = 1 will never be reached. In the main method above, we attempt to call the factorial function with the argument -5. We do not handle or catch the exception inside the main method meaning that we do not include a try-catch block giving instructions on how what the program should do when it sees the exception. As a result, the program exits immediately (really, the function std::terminate() is called), giving an error message along the lines of terminating with uncaught exception of type std::invalid argument: negative number, and Does not print is never printed. To handle/catch the exception, we use a try-catch block: 1 int main ( ) { 2 bool again = true ;

2 3 double input ; 4 while ( again ) { 5 std : : c i n >> input ; 6 try { 7 std : : cout << f a c t o r i a l ( input ) << \n ; 8 again = f a l s e ; catch ( const std : : i n v a l i d a r g u m e n t& e ) { 10 std : : c e r r << e. what ( ) << std : : endl ; In this code, we query the user for a positive integer for which to calculate the factorial. if a positive integer is not entered, the factorial function throws an exception, and the code skips again = false and enters the catch block. Notice that the catch block will only except an object that can be bound to an std::invalid argument const reference. Inside the catch block the.what() function of the exception object is called, printing out the error message used to construct the exception object inside of factorial. Here, the std::err object is used for printing out the error message. A dedicated error stream is used is because the buffer of std::cout may already contain some data, which we do not want to change just to print out an error message. Example output from the code above is given below n e g a t i v e number non i n t e g e r If one does not know the specific details of a function, or if many possible exceptions can be thrown by a function and it is not desired to create many catch blocks, one can do the following 1 int main ( ) { 2 try { 3 f u n c t i o n ( input ) ; // pseudocode 4 } catch ( const std : : e x c e p t i o n& e ) { 5 std : : e r r << e. what ( ) << std : : endl ; 6 } catch (... ) { 7 std : : e r r << unknown e x c e p t i o n caught << std : : endl ; Here, a generic std::exception object is caught in the first catch block, which will catch many exceptions of the exception library. The elipsis in the second catch block will catch any exception not caught by the first catch block. Indeed, in the example above we only threw an std::exception object, but any expression can be thrown: 1 int f a c t o r i a l ( double n ) { 2 i f ( static cast <int >(n )!= n ) { 3 throw 10; 4 } else i f ( n < 0) { 5 throw h e l l o ; 6 } 7 int m = 1 ; 8 for ( int i = 2 ; i <= n ; ++i ) { 9 m = i ; 10 } 11 return m; 2

3 1.2 Exception safety and noexcept The term exception safety refers to designing your code so that thrown exceptions do not cause memory leaks. Indeed, consider the following 1 void whoops ( ) { 2 throw std : : e x c e p t i o n ; 4 fun ( ) { 5 int a r r = int [ ] ; 6 whoops ( ) ; 7 delete [ ] a r r ; 9 int main ( ) { 10 try { 11 fun ( ) ; 13 // more code 14 } The function fun creates a memory leak because fun exits before delete[] is used on the array. Thus, the code above is not exception safe. To make the code exception safe, one option is to use a try block inside of fun: 1 fun ( ) { 2 int a r r = int [ ] ; 3 try { 4 whoops ( ) ; 5 } catch (... ) { 6 delete [ ] a r r ; 7 throw ; This can become annoying when writing code however. A more natural appoach is to make sure that all dynamically allocated memory will be deleted when the stack is naturally unwound; i.e. we should remember the RAII idiom. 1 void whoops ( ) { 2 throw std : : e x c e p t i o n ; 4 fun ( ) { 5 std : : unique ptr <int [] > a r r = std : : make unique<int [ ] > ( ) ; 6 whoops ( ) ; 8 int main ( ) { 9 try { 10 fun ( ) ; 12 // more code The code above is exception safe, because when the unique ptr above is destroyed, the underlying data will be deallocated. Therefore, there will be no memory leak. (We have to trust that the unique ptr class is exception safe!) However, we don t always have to be paranoid and imagine the worst-case scenario. The keyword noexcept can be used to guarantee that a function will not throw an exception: 1 int fun ( ) noexcept { 3

4 2 int x = 5 ; 3 return x ; 4 } 5 void fun2 ( ) { 6 int ptr = new int [ ] ; 7 fun ( ) ; 8 delete ptr ; This code is exception safe because fun() will never throw an exception; thus, the delete statement will always be reached. 1.3 Stack unwinding Stack unwinding refers to the process of an exception being passed up the call stack until a matching catch block is found to handle the exception. Consider the code below 1 void fun1 ( ) { 2 throw 1; 4 void fun2 ( ) { 5 fun1 ( ) ; 6 std : : cout << 1 << std : : endl ; 8 void fun3 ( ) { 9 try { 10 fun2 ( ) ; catch ( const std : : s t r i n g& s ) { 12 std : : c e r r << 2 << std : : endl ; catch ( const int x ) { 14 std : : c e r r << 3 << std : : endl ; 15 throw ; 16 } 1 18 int main ( ) { 19 try { 20 fun3 ( ) ; 21 } catch (... ) { 22 std : : c e r r << 4 << std : : endl ; 2 24 std : : cout << 5 << std : : endl ; 25 } We trace the order in which the code above runs: 1. main calls fun3, fun3 calls fun2, fun2 calls fun1. 2. fun1 throws fun2 does not handle the exception, so 1 is not printed and stack is unwound to fun3. 4. The exception is caught by the second catch block in fun3, printing out 3. The exception is thrown again, and the stack is unwound to main. 5. In main, the general (...) catch block catches the exception, printing 4. Finally, 5 is printed. 4

5 As the stack is unwound, data local to the scopes being unwound is cleaned up. For example, 1 struct A { 2 A( const int x ) : x ( x ) {} 3 int x ; 4 A( ) { std : : cout << x << std : : endl ; } 5 } 6 void fun ( ) { 7 A a ( 1 ) ; 8 throw 1; 10 void fun1 ( ) { 11 A a ( 2 ) ; 12 fun ( ) ; 14 int main ( ) { 15 try { 16 fun1 ( ) ; 1 catch (... ) { 18 std : : c e r r << h i << std : : endl ; 1 20 } Here, we will see 1 print out, then 2. When the exception is thrown in fun(), the variables local to fun() are deleted, causing the destructor of the variable a to be called. Similarly, in fun1(), the destructor of a is called as well. 5