Advanced Programming II CS 509 Class Notes

Lecture Notes for Advanced Programming II

30 September 2003 - Exceptions

Exceptions

The Error Problem
Exception Basics
Exception Problems
Basic Exception Mechanisms
- The throw Statement
- The catch Statement
- The try Statement
Exception Problems II
Exception Mechanism Refinements
Exception Problems III
Further Exception Refinements
Points to Remember

Errors

What happens if there's an error in a constructor?

// How can shred::shred() 
// handle internal errors?

shred s(e1, e2);

What happens if there's an error in an overloaded operator?

// How can shred::operator + () 
// handle internal errors?

s1 = s1 + s2;

The Error Pass-Along Problem

The code can not handle errors.
- Not always possible or advisable.
The code can print an error message and die.
- Helpful, but not always useful.
The code can try to handle the error.
- Possible, but difficult because the context isn't known.
The code can indicate an error some how.
- Better, but how?
This is the error pass-along problem.

Solving the Error Pass-Along Problem

You can function return error values.
```
int e = f();
```
- Complicates normal functions.
- Constructors can't return any values.
You can pass error values through procedure parameters.
```
int f(int & err) { ... }
```
- Operators only have two parameters.
You can use globals to pass error values.
```
f();
if (err != 0) { ... }
```
- Not structured, not multi-thread safe.

Exceptions

Exceptions provide an alternative mechanism for delivering error indications.
Exceptions are not propagated along parameters, return values, or globals.
- This is known as out-of-band communication.
- This property makes them useful for constructors and operators.
Uninterested code can chose to ignore exceptions.
- But, alas, it's not that simple.

Exception Basics

Each instance of a called procedure has a stack frame.
- The stack frame holds parameters, local variables, and other things related to the called procedure.
The call stack contains the stack frames of all currently called procedures.
When one one procedure calls another, the called procedure pushes its stack frame on the call stack.
When the top procedure returns, it pops its call stack frame off the call stack.

Call Stack Example

Consider

int main () {   int f() {   int g() {
  f()             g()         if (b) g()
  }               }           }

Initially main() is called, and main() calls f().
f() then calls g().
Eventually f() and g() return.
main() returns and the program ends.

Exceptions and the Call Stack

The top of the call stack can throw an exception.
- This terminates the throwing procedure, popping it from the call stack.
Each new call-stack top may catch the exception, or let it pass.
- Catching the exception continues execution at the catching procedure.
- Letting the exception pass terminates the procedure, popping it from the call stack.
  - The new call-stack top repeats the procedure.
Popping the call stack because of exceptions is known as unwinding the call stack.
Completely unwinding the call stack terminates the program.

Exception Problems

Exceptions are completely different from everything else.
- Another new and different thing to watch.

Intervening procedures have no chance to clean up.

f() {
  char * cp = new char [100];
  FILE * inf = open(fname, O_RDONLY);
  g()
  delete [] cp;
  close(inf);
  }

If g() throws an exception, f() terminates immediately.

Coordinated exceptions among independent modules requires work.
- Which procedures throw what exceptions when?

Basic Exception Mechanisms

C++ has three statements for dealing with exceptions.
1. throw throws exceptions.
2. catch catches exceptions.
3. try delimits exception handling.

The `throw` Statement

The throw statement lauches (throws) an exception.
throw expr throws the value expr as an exception.
- Like return in syntax and semantics.
expr can be a value of any type.

Examples

throw 1;

throw strack_trace("g()"));

throw new strack_trace("g()"));

The `catch` Clause

The catch clause catches thrown exceptions.
catch ( type-spec [ name ] ) { body }
- This syntax is similar to a one-parameter procedure definition.
```
catch (exception_type ex) {
  std::cerr << ex.what();
  }
```
The ellipsis catch(...) { } catches any exception.
- The caught exception has an unknown type.
When caught, the body is executed with name (if defined) as a local variable.
- With no name, the caught exception is inaccessable.
```
int main() {
  try { ... }
  catch (...) { 
    std::cerr << "Uncaught exception!"; 
    }
```

Catching Exceptions

A catch clause with exception type ET catches the exception value of type EVT when either
- EVT is a non-class type and EVT and ET exactly match or
- EVT is a class type and ET is a (not necessarily proper) ancestor class of EVT.

Examples.

throw 1 catch (int e) {...} throw 'a' ~~catch (int e) {...}~~ throw "help!" ~~catch (string e) {...}~~ const char * e = ... throw e ~~catch (char * e) {...}~~

class red {} class mauve : red {} class blue throw red(); catch (red e) {...} ~~catch (mauve e) {...}~~ ~~catch (blue e) {...}~~ throw mauve(); catch (red e) {...} ~~catch (mauve e) {...}~~ ~~catch (blue e) {...}~~

The try Statement

try { body } catch-cls . . .
Execute the code in body and fall off the end with no exception.
Jump from body to the catch-clss on exception

A normal scope exit; destructors are called.

Search for a matching catch-cls in order.

An exception is considered handled as soon as a match is found.

After executing the associated catch body, continue after the try.
If no catch-stmt matches, terminate the current procedure and continue unwinding the stack.

Exception Problems II

The scope of the try is not the scope of a catch.

Declarations in the try are not accessable from catch clauses.

try { char * cp; } catch (...) { ~~new [] cp;~~ }

Exception refinements - it gets confusing.
- An exception not handled by main() causes termination.
- An exception thrown in a catch body is like any other exception.
- Exceptions raised in destructors cause immediate termination - no stack unwinding.

Exception Mechanism Refinements

A catch clause can rethrow an exception using throw.
- That's a throw without a value.
```
try { ... }
catch (stack_trace & st) {
  st.push_back("f()");
  throw;
  }
```
A procedure can list the exceptions it throws with a throw clause.
- throw ( ex1, ex2, . . . )
- Follows the procedure's formal parameter list.
- Only the listed exceptions can be thrown from the procedure.
  - Other exceptions cause termination.
- A procedure can throw all exceptions by default.

Exception Problems III

throw clauses are useful but dangerous - must list all possible exceptions; unlisted exceptions get turned into unexpected exceptions

Standard Exceptions

The Standard defines two sets of exceptions.
- The exception base class in <exception>.
- A family of standard exceptions in <stdexcept>.

The exception class is a base class for other exceptions.

class exception {
  public:
    exception() {}
    virtual ~exception() {}
    virtual const char* what() const
      { return "class exception"; }
  };

Use exception to catch any standard exception.

try { ... }
catch (const std::exception & ex) {
  std::cerr << ex.what() << '\n';
  }

Defined Standard Exceptions

<stdexcept> defines three types of standard exceptions.
1. Exceptions for language errors.
  - Out-of-memory errors, casting errors.
2. Exceptions for library errors.
  - Bad index values, invalid argument values.
3. Exceptions for runtime errors.
  - Under- or overflow errors, range errors.

Standard exceptions have a string-argument constructor.

class logic_error : std::exception {
  public:
    explicit logic_error(
      const std::string &);
  };

Defining Exceptions

You can define an exception as a child of std::exception.

class my_exception 
  : public std::logic_exception {
  public:
    explicit my_exception(const char *);
    const char * what() const;
  private:
    // whatever.
  };

You can also inherit from a standard exception.

class my_exception 
  : public std::exception {
  public:
    explicit my_exception(
      const std::string & emsg)
      : std::out_of_range(emsg) { }
  };

Inheriting from a standard exception is simpler than inheriting from std::exception.

Further Exception Refinements

C++ throws several exceptions - bad_alloc in new in particular.
- There's also a non-throwing new - this used to be standard.
auto_pointers provide a means for automatic resource recovery on exceptions.

Points to Remember

Don't use them - nasty, asynchronous, implicit control flow.
If you do use them,
- Make sure they indicate exceptional conditions - don't use them to exit a loop or return from a procedure; lisp programmers beware
- Keep it as simple as possible - short throw-catch relations and simple values returned

This page last modified on 13 October 2003.