Exceptions in C++

Exception handling in C++ is provided via the try, catch, and throw keywords. Code that might raise (or throw) an exception are put into a try block. The try block is then followed by one or more exception handlers, which are declared with catch.

Example:

 
FILE *f;

try
  {
  f = fopen( "myfile.txt", "r" );
  if ( f == NULL )
    throw "opening file";

  }
catch ( const char* p )
  {
  printf( "Error %s while %s", strerrror(errno), p );
  exit();
  }

You can throw and catch exceptions of any type. For built in exceptions (= those generated by signals), there is a proposed ANSI spec based on a class exception. exception has two children, logic_error and runtime_error, which in turn have many children (domain_error, invalid_argument, length_error, and out_of_range for logic_error and range_error and overflow_error for runtime_error). For example, in
```
  try 
    { 
    // dangerous stuff 
    }
  catch (overflow_error oe)
    {
    printf( "Overflow error\n" );
    }
  catch (exception e)
    {
    printf( "Some exception happened.  Deal.\n" );
    throw; // same as throw e; in the context of an exception handler
    }
  catch (...)
    {
    // this would catch anything, even a throw "foobar";
    }
```
the first exception handler is used if there was an overflow error in g and the second handler is used if there was any other type of exception. Exception handlers are examined in order to see if they match the type whenever an exception is raised, so reversing the order of the above handlers wouldn't be a good idea.
All of the above assumed that everything that was thrown was caught in the same function. But what if you have a function f calling a function g, and you want to raise exceptions in g and then catch them inside of f?
Well, everything works the same way except that you must declare what kind of exceptions g can throw. For example:
```
void g() throw(int)
{
  throw 5;
}

void f()
{
  try
    {
    g();
    printf( "This will never be printed.\n" );
    }
  catch( int i )
    {
    //  stuff
    }
}
```
is valid, but it would give a run time error if you didn't have the throw(int) specifier in g's declaration.

The fine print:

You can't have throw specifiers in typedefs.

You can only override or assign functions if you go from a more restrictive to a less restrictive throw type. Examples:

          void (*pf1)();    // no exception specification
          void (*pf2) throw(A);

          void f()
          {
                  pf1 = pf2;  // ok: pf1 is less restrictive
                  pf2 = pf1;  // error: pf2 is more restrictive
          }

          class B {
              virtual void f() throw (int, double);
              virtual void g();
          };

          class D: B {
              void f();                    // ill-formed
              void g() throw (int);        // OK
          };

You can declare yourself to throw more exceptions than you actually do.

Next Slide