Question

I would like to create a hierarchy of exceptions. I used the C++ idiom “Polymorphic Exception”.

The difficult bit is that I would like those classes to derive from std::exception – to be able to catch any exception at any point of the code with a try … catch(exception &e).

However, I want to handle exceptions differently whether the exception comes from std::exception or from my user-defined exceptions.

This would suggest to use polymorphism, however I cannot define a virtual function on std::exception.

I also tried with function templates (see code below), but it doesn’t work because the template function called is determined at compile time.

#include <iostream>
#include <string>
using namespace std;

#include <boost\type_traits\is_base_of.hpp>
#include <boost\utility\enable_if.hpp>


class BaseError :public exception {
  public:
    virtual void raise(){throw *this;}
    virtual string msg (){ return "This is the base class"; }
  };

class DerivedError: public BaseError {
  public:
    void raise(){throw *this;}
    string msg (){ return "This is the derived class"; }
  };

template <typename T>
typename boost::disable_if<boost::is_base_of<BaseError, T>>::type
handleException(T &e)
{
    cout << "Handling generic exception" << endl;
    cout << e.what() << endl;
}
template <typename T>
typename boost::enable_if<boost::is_base_of<BaseError, T>>::type
handleException(T &e)
{
    cout << "Handling specific exception" << endl;
    cout << e.msg() << endl;
}


int main () {
  BaseError b;
  handleException(b);
  // prints "Handling specific exception"
  // prints "This is the base class"
  try{
      throw exception("Exception !!!");
  }
  catch (exception &e){
      handleException(e);
      // prints "Handling generic exception"
      // prints "Exception !!!"
  }
  try{
      BaseError b;
      b.raise();
  }
  catch (exception &e){
      handleException(e);
      // prints "Handling generic exception" - I would like the specific behaviour
      // prints "Unknown exception"
  }
  try{
      DerivedError d;
      d.raise();
  }
  catch (exception &e)
  {
      handleException(e);
      // prints "Handling generic exception" - I would like the specific behaviour
      // prints "Unknown exception"
  }
  return 0;
}

Any idea of how to achieve this?

Thanks in advance!

Answer 1

You can rethrow an exception at any point, it will be defined if it happens between a catch. For instance:

try
{
    // something that throws an exception
} catch(std::exception& e) {
    try
    {
        throw; // rethrows the original exception
    } catch(std::runtime_error& e) {
        // handle runtime error
    } catch(std::exception& e) {
        // handle everything else
    }
}

Now the nested try-catch block could be anywhere, it could be a function or even an object destructor. You can compose a set of objects that handle a particular exception, chain them together and call throw; at the end of the chain. Pseudo code:

template< typename E, typename Base = void >
struct exception_handler : Base
{
    void handle() const
    {
        try
        {
            Base::handle();
        } catch( E& e ) {
            // do something
        }
    }
};

template< typename E >
struct exception_handler< E, void >
{
    void handle() const
    {
        try
        {
            throw;
        } catch( E& e ) {
            // do something
        }
    }
};

Then the above example can be construed like this:

try
{
    // something that throws an exception
} catch(std::exception& e) {
    exception_handler<
        std::exception
      , exception_handler<
            std::runtime_error
        >
    > handler;
    handler.handle();
}

The same hierarchy can be created manually, using inheritance and regular classes, where you define each of the exception levels and how to handle them.

struct runtime_error_handler : base_handler
{
    void handle() const
    {
        try
        {
            throw;
        } catch( std::runtime_error& e ) {
            // if the original exception was a runtime_error it will be caught here
            // otherwise it will be propagated up the stack to exception_handler

            // do something if runtime_error
        }
    }
};

struct exception_handler : runtime_error_handler
{
    void handle() const
    {
        try
        {
            runtime_error_handler::handle();
        } catch(std::exception& e) {
            // do something else in the general case
        }
    }
};