Handling Exceptions. Questions:

Transcription

1 Handling Exceptions Questions: 1

2 1. Why can t we do exception handling by embedding potentially troublesome source code statements inside if blocks -- the way it s done in C when you try to open a file for I/O? 2

3 2. How does one do multi-level return in C? 3

4 3. What are the shortcomings of the setjmp-longjmp mechanism with regard to exception handling needed for OO programming? 4

5 4. What s the type of the global variable in which the program environment is saved when a setjmp instruction is executed? 5

6 5. In the setjmp--longjmp mechanism of C for multi-level return, which call does most of the work? Is it setjmp? Or, is it lonjmp? 6

7 6. In the try--catch--throw mechanism of C++, which call does most of the work? Is it the call to try or the call to throw or the call to catch? 7

8 7. In what manner does the throw clause walking the function stack backwards differ from the unwinding of a function stack? 8

9 8. Is the following syntax legal in C++? If it is legal, does it have any style errors? class myexception ; void f() throw myexception(); int main() f(); catch( myexception ) 9

10 9. C++ allows primitive types to be thrown as exception. So why use class types? 10

11 10. Is the following syntax legal in C++: class myexception ; class Err ; void f() throw( myexception ) throw myexception(); void g() throw( Err ) f(); catch( myexception e ) throw Err(); void h() g(); int main() h(); catch( Err ) cout << caught Err << endl; 11

12 C++ Usage Patterns for Exception Handling 12

13 Usage Pattern 1: #include <iostream> void f() throw 1; int main() f(); catch( int ) cout << "caught it"; 13

14 Usage Pattern 2: #include <iostream> class myexception ; void f() throw myexception(); int main() f(); catch( myexception ) cout << "caught myexception"; // (A) // (B) 14

15 Usage Pattern 3: #include <iostream> class myexception ; void f() throw( myexception ) throw myexception(); // (A) int main() f(); catch( myexception ) cout << "caught myexception"; 15

16 Usage Pattern 4: #include <iostream> using namespace std; class MyException ; class Err ; void f( int j ) throw( MyException, Err ) if ( j == 1 ) throw MyException(); if ( j == 2 ) throw Err(); int main() f( 1 ); catch( MyException ) cout << "caught MyException -- arg must be 1" << endl; catch( Err ) cout << "caught Err -- arg must be 2" << endl; f( 2 ); catch( MyException ) cout << "caught MyException -- arg must be 1" << endl; catch( Err ) 16

17 cout << "caught Err -- arg must be 2" << endl; return 0; 17

18 Usage Pattern 5: #include <iostream> class myexception ; class Err ; void f() throw( myexception ) throw myexception(); void g() throw( Err ) f(); catch( myexception e ) cout << "oh my" << endl; throw Err(); int main() g(); catch( Err ) cout << "caught Err" << endl; 18

19 Usage Pattern 6: #include <iostream> class myexception ; class Err ; void f() throw( myexception ) throw myexception(); void g() throw( Err ) f(); catch( myexception e ) cout << "oh my" << endl; throw Err(); void h() g(); int main() h(); catch( Err ) cout << "caught Err" << endl; 19

20 Usage Pattern 7: #include <iostream> class myexception ; class Err ; void f() throw( myexception ) throw myexception(); void g() throw( Err ) f(); catch( myexception e ) cout << "oh my" << endl; throw Err(); void h() throw( Err ) g(); int main() h(); catch( Err ) cout << "caught Err" << endl; 20

21 Usage Pattern 8: #include <iostream> class myexception ; // (A) void f() throw( myexception ); int main() f(); catch( myexception ) cout << "caught myexception"; void f() throw( myexception ) throw myexception(); // (B) 21

22 Usage Pattern 9: #include <iostream> #include <string> class myexception string message; public: myexception( string m ) message = m; string getmessage() return message; ; // (A) // (B) // (C) void f() throw( myexception ); int main() f(); catch( myexception ex ) cout << ex.getmessage(); // (D void f() throw( myexception ) throw myexception( "hello there" ); // (E) 22

23 Handling Exceptions: Differences between C++ and Java 1. While literally any type can be used for throwing in C++, that s not the case in Java. An object that s used for throwing in Java must of type that is a subclass of Throwable. By convention, however, user-defined exceptions are of type Exception, a subclass of Throwable. Therefore, if we wish to write a Java method that throws an exception of the user-defined type MyException, we must define MyException by extending Exception, as in class MyException extends Exception //... 23

24 2. If a function is written so as to throw an exception, that fact must be declared in the header of the function. So if a function f() is written to throw the exception MyException, we have no choice but to include the throws MyException clause in the header of the function, as in void f(int j) throws MyException //... throw new MyException( //... ); Also note the keyword new for constructing an object of type MyException. 24

25 3. An exception-throwing function can only be invoked in one of the following modes: It must be invoked inside a try catch block and the exception must be caught; or The calling function must re-throw that exception so that it can be caught elsewhere, possibly by the system-supplied default exception handler. The calling function can do both of the above. 25

26 4. Another important difference between the Java syntax and the C++ syntax is that a parameter must be explicitly specified for the catch block. In other words, one now has no choice but to say catch( MyException e )... and explicitly mention an identifier, in this case e of type MyException in the parameter list of catch() even if this parameter does not get used for anything inside the definition of the catch block. 26

27 Java Syntax for Exception Handling catch( exception_type_1 identifier_1 ) catch( exception_type_2 identifier_2 ) catch( exception_type_3 identifier_3 ) finally

28 Java Usage Patterns for Exception Handling 28

29 Usage Pattern 1: class MyException extends Exception class Test static void f( ) throws MyException throw new MyException(); public static void main( String[] args ) f(); catch( MyException e ) System.out.println( "caught MyException" ); 29

30 Usage Pattern 2: class MyException extends Exception class Test static void f( ) throws MyException System.out.println( "inside do nothing f()" ); public static void main( String[] args ) f(); catch( MyException e ) System.out.println( "caught MyException" ); 30

31 Usage Pattern 3: class MyException extends Exception class Err extends Exception class Test static void f( int j ) throws MyException, Err if ( j == 1 ) throw new MyException(); if ( j == 2 ) throw new Err(); public static void main( String[] args ) f( 1 ); catch( MyException e ) System.out.println( "caught MyException -- arg must be catch( Err e ) System.out.println( "caught Err -- arg must be 2" ); f( 2 ); catch( MyException e ) System.out.println( "caught MyException -- arg must be catch( Err e ) System.out.println( "caught Err -- arg must be 2" ); 31

32 Usage Pattern 4: class MyException extends Exception class Err extends Exception class Test static void f() throws MyException throw new MyException(); static void g() throws Err throw new Err(); static void h() throws MyException, Err f(); g(); public static void main( String[] args ) h(); catch( MyException e ) System.out.println( "caught MyException" ); catch( Err e ) System.out.println( "caught Err" ); 32

33 Usage Pattern 5: FileReader constructor -- throws FileNotFoundExcept read() -- throws IOException close() -- throws IOException 33

34 import java.io.*; class Test static void foo() throws Exception throw new Exception(); static void bar() throws Exception FileReader input = null; input = new FileReader( "infile" ); // (A) int ch; while ( -1!= ( ch = input.read() ) ) // (B) if ( ch == A ) System.out.println( "found it" ); foo(); // (C) finally if ( input!= null ) input.close(); System.out.println( "input stream closed successfully" ) System.out.println( "Exiting bar()" ); // <<<<< (D) public static void main( String[] args ) 34

35 bar(); catch( Exception e ) System.out.println( "caught exception in main" ); 35

36 Usage Pattern 6: class MyException extends Exception class Test static void f() throws MyException throw new MyException(); static void g() throws MyException f(); catch( MyException e ) System.out.println( "catching and re-throwing in g" ); throw new MyException(); public static void main( String[] args ) g(); catch( MyException e ) System.out.println( "caught MyException in main" ); 36

37 Usage Pattern 7: class MyException extends Exception String message; // (A) public MyException( String mess ) message = mess; // (B) class Test static void f() throws MyException throw new MyException( "Hello from f()" ); // (C) public static void main( String[] args ) f(); catch( MyException e ) System.out.println( e.message ); 37

38 Checked and Unchecked Exceptions in Java All of the Java exception handling examples we have shown so far deal with checked exceptions. For a checked exception, the compiler makes sure that your code makes provisions for either catching the exception or for re-throwing it. Java also supports another kind of exceptions unchecked exceptions that are objects of type RuntimeException or of type Error. 38

39 An unchecked exception is beyond the purview of the compiler, in the sense that the compiler will not insist that your program include exception handling code (meaning code to either catch the exception, or to re-throw the exception). However, if a method capable of throwing an unchecked exception actually ends up throwing the exception during program execution, the exception will be trapped by the runtime and will cause termination of the Java Virtual Machine unless, of course, your program catches the exception. 39

40 Unchecked exception of type Error usually indicate serious problems at run time; there is never a good reason for catching them. Some examples of system-defined exceptions that are of type Error: OutOfMemoryError, NoSuchMethodError, StackOverflowError, and so on. Examples of system-defined exceptions of type RuntimeException include: ArithmeticException, ClassCastException, IllegalArgumentException, NullPointerException, and so on. 40

41 //RuntimeExcep.java class MyException extends RuntimeException public MyException() super(); public MyException( String s ) super( s ); class Test static void f( ) throws MyException throw new MyException( "Exception thrown by function f()" public static void main( String[] args ) f(); 41