must remember to check return value OR, must pass
label/exception handler to every function Caller Function return
status Caller Function label to subprogram Fortran strategy
Slide 3
Error detection code is tedious to write and it clutters the
program Exception propagation allows a high level of reuse of
exception handling code Encourage programmers to consider all
events that could occur that might need to be handled especially
checked exceptions.
Slide 4
An exception is an unusual event detectable by either hardware
or software An exception is raised/thrown when its associated event
occurs The exception handler code determines what to do
Slide 5
How to bind an exception to a handler What information to make
available about exception Is it possible to continue after an
exception? Does the language have any built-in exceptions? Are
there user-defined exception types Is there a default exception
handler? Can exceptions be disabled? What decisions were made for
Java?
Slide 6
Added to C++ in 1990 Exceptions are user- or library-defined
(none in language definition) Exception Handlers Form (like Java):
try { -- code that is expected to raise an exception } catch
(formal parameter) { // only 1 parm -- handler code }... catch
(formal parameter) { -- handler code }
Slide 7
catch is the name of all handlers--it is an overloaded name, so
the formal parameter of each must be unique The formal parameter
need not have a variable It can be simply a type name to
distinguish the handler it is in from others, e.g. catch(int)
rather than catch (int x) The formal parameter variable can be used
to transfer information to the handler The formal parameter can be
an ellipsis (), in which case it handles all exceptions not yet
handled Compare to Java: Possible to throw/catch an int? Does
formal parameter need a variable? (yes) How does the handler get
information? What mechanism is used in place of ? How does this
work?
Slide 8
Exceptions all raised explicitly by: throw expression;
expression may be a literal or variable of any type A throw without
an operand can only appear in a handler; when it appears, it simply
re-raises the exception, which is then handled elsewhere Syntax to
throw exception in Java?
Slide 9
Problem! main calls function a a calls function b exception
occurs in b If no try/catch in b, exception propagates to a If no
try/catch in a, exception propagates to main If no try/catch in
main, execution terminates (in C++, can override default handler,
named unexpected) Continuation. If exception is handled, execution
continues after last catch (unless handler calls exit of course).
main a b call Both Java and C++ propagate exceptions
Slide 10
http://google-
styleguide.googlecode.com/svn/trunk/cppguide.html#Exceptions
http://www.parashift.com/c++-faq/exceptions-avoid-spreading-out-
error-logic.html
http://www.parashift.com/c++-faq/exceptions-avoid-spreading-out-
error-logic.html
http://stackoverflow.com/questions/19073441/google-c-coding-
style-no-exceptions-rule-what-about-multithreading
http://stackoverflow.com/questions/19073441/google-c-coding-
style-no-exceptions-rule-what-about-multithreading
http://stackoverflow.com/questions/1744070/why-should-
exceptions-be-used-conservatively
http://stackoverflow.com/questions/1744070/why-should-
exceptions-be-used-conservatively
http://www.joelonsoftware.com/items/2003/10/13.html
http://www.joelonsoftware.com/items/2003/10/13.html
https://files.ifi.uzh.ch/rerg/arvo/courses/kvse/uebungen/Dijkstra_
Goto.pdf Put some thoughts on paper, be ready to share
Slide 11
The Java library includes two subclasses of Throwable : Error
Thrown by the Java interpreter for events such as heap overflow
Never handled by user programs Exception User-defined exceptions
are usually subclasses of this Has two predefined subclasses,
IOException and RuntimeException (e.g.,
ArrayIndexOutOfBoundsException and NullPointerException)
Slide 12
Exceptions of class Error and RunTimeException and all of their
descendants are called unchecked exceptions All other exceptions
are called checked exceptions (compiler checks that your code
handles all exceptions occur at runtime) Methods containing code
that can throw a checked exception must either: List the
exception(s) in a throws clause, or Handle the exception (e.g.,
with try/catch) Example throws clause (not the same as throwing an
exception!): public void myFunction() throws Exception
Slide 13
A method cannot declare more exceptions in its throws clause
than the method it overrides. Example: If you override run in a
Thread class, you cannot add a throws clause. A method that calls a
method with a checked exception in its throws clause has three
alternatives: 1. Catch and handle the exception 2. Catch the
exception and throw an exception that is listed in its own throws
clause 3. Declare that exception in its throws clause and do not
handle it public void A() throws BadException { } public void B() {
try { A() } catch (BadException e) { } } public void C() throws
AnException{ try { A() } catch (BadException e) { throw
(AnException) } } public void D() throws BadException { A() }
Slide 14
Can appear at the end of a try construct Form: finally {... }
Purpose: To specify code that is to be executed, regardless of what
happens in the try construct (e.g., to close file or database
connection). Finally is executed even if there is a return
statement in the block.
Slide 15
try { for (index = 0; index < 100; index++) { if () {
return; } //** end of if } //** end of try clause finally { } //**
end of try construct * Java exercise has examples to play with
Slide 16
Exceptions are raised using the raise method of Kernel The
rescue clause is used to handle exceptions Exceptions are instances
of the Exception class (or a subclass) Subclasses do not add
methods or behavior, but allow exceptions to be categorized Most
exceptions extend StandardError Other exceptions are low-level,
typically not handled by programs * Exception info directly from
The Ruby Programming Language
Slide 17
message method returns a string more suitable for programmers
than end users backtrace returns the call stack array of strings
filename : linenumber in methodname
Slide 18
fail is synonym (use if expect program to end) Several ways to
invoke raise: with no arguments. If inside rescue, re-raises same
exception, otherwise raises RuntimeError with single Exception
object. Not common. with single String argument. Creates
RuntimeError with that string as message. Very common. with
exception object, string (for message) and array of strings (for
backtrace).
Slide 19 = 1, got #{n}" if n < 1 retur"> = 1, got #{n}"
if n < 1 return 1 if n == 1 n * factorial(n-1) end Can provide a
custom stack trace def factorial4(n) if n < 1 raise
ArgumentError, "Expected argument >= 1, got #{n}", caller end
return 1 if n == 1 n * factorial(n-1) end"> = 1, got #{n}" if n
< 1 retur" title="def factorial(n) raise "bad argument" if n
< 1 # raise ArgumentError if n < 1 # raise ArgumentError,
"Expected argument >= 1, got #{n}" if n < 1 retur">
def factorial(n) raise "bad argument" if n < 1 # raise
ArgumentError if n < 1 # raise ArgumentError, "Expected argument
>= 1, got #{n}" if n < 1 return 1 if n == 1 n *
factorial(n-1) end Can provide a custom stack trace def
factorial4(n) if n < 1 raise ArgumentError, "Expected argument
>= 1, got #{n}", caller end return 1 if n == 1 n *
factorial(n-1) end
Slide 20
rescue is part of Ruby language (not a Kernel method) clause
that can be attached to other Ruby statements typically attached to
begin begin # statements, possible exceptions rescue # code to deal
with exceptions end # if no exception, code continues here, code in
rescue is not executed
Slide 21
rescue handles any StandardError global variable $! refers to
raised exception better to specify variable in rescue begin x =
factorial(0) rescue => ex puts "#{ex.class}: #{ex.message}"
end
Slide 22 = 1, got #{n}" if n < 1 return 1 if n =="> = 1,
got #{n}" if n < 1 return 1 if n == 1 n * factorial(n-1) end
begin x = factorial5("a") rescue ArgumentError => ex puts "Try
again with argument > 1" rescue TypeError => ex puts "Try
again with an integer" end Does the order matter?"> = 1, got
#{n}" if n < 1 return 1 if n ==" title="def factorial5(n) raise
TypeError, Need integer" if not n.is_a? Integer raise
ArgumentError, Need argument >= 1, got #{n}" if n < 1 return
1 if n ==">
def factorial5(n) raise TypeError, Need integer" if not n.is_a?
Integer raise ArgumentError, Need argument >= 1, got #{n}" if n
< 1 return 1 if n == 1 n * factorial(n-1) end begin x =
factorial5("a") rescue ArgumentError => ex puts "Try again with
argument > 1" rescue TypeError => ex puts "Try again with an
integer" end Does the order matter?
def explode raise "bam!" if rand(10) == 0 end def risky begin
10.times do explode #raises error ~10% of time end rescue TypeError
# won't catch RuntimeError puts $! end# RuntimeError not handled,
will propagate "hello" # if no exception end def defuse begin puts
risky rescue RuntimeError => e# handle propagated error puts
e.message end defuse QUICK EX: Trace code
Slide 24
retry with rescue, reruns block of code that rescue is attached
to. Useful for transient failures such as overloaded server. Be
sure to limit number of retries. ensure code that always runs, for
housekeeping like disconnecting from database, closing files, etc.
not covered: subtle details for ensure rescue can be used as a
statement modifier (y = factorial(x) rescue 0 #returns 0 if
error)
Slide 25
similar to a labeled break, but can break out of multiple
levels not used for exception handling used infrequently, details
not covered