Thread: Catching exceptions thrown from constructor of a global instance of a class

I'm not sure how close to the spec this reference is, but it says that:

The unexpected handler function... shall end either by teminating (calling terminate or cstdlib's exit or abort) or by throwing an exception (even rethrowing the same exception again).

So I don't know if you're expecting to "regain control" in the sense of being able to continue execution, but I can't see how you could possibly do that in a sane way. The best I can come up with is this example:

Code:

#include <iostream>
#include <exception>
#include <cstdlib>

void handler()
{
    std::cout << "handler()" << std::endl;
    exit(0);
}

class Object
{
public:
    Object() throw() {
        std::set_unexpected(&handler);
        throw std::exception();
    }
};

Object object;

int main()
{
}

Bottom line: If you want to control what happens when non-local static objects throw exceptions in constructors, use a pointer and initialize it in main().

I'd suggest you need to ask the question of why construction of a static object is throwing an exception at all. Non-local static objects are typically constructed before main() is called (technically they are constructed before any code that uses them is executed, but few compilers are smart enough to wait, so will simply construct them as early as possible during program startup) so it is better to avoid having failures occur, rather than trying to regain control afterward.

In any event, to answer your question, it is necessary to ensure that set_unexpected() is called before the (potential) failure occurs. This means one of;

1) calling set_unexpected() in a constructor of some other object. The problem then becomes one of guaranteeing that construction of "other object" does not fail. It also requires that "other object" is constructed first - which is difficult to achieve, since the construction order of non-local static objects is not defined.

2) calling set_unexpected() in the constructor of a base class. This works, since base class constructors are guaranteed to be called before derived class constructors.

3) calling set_unexpected() within your constructor that can fail, before it performs whatever action triggers an exception.

Generally, I would prefer option 2.

Whichever option you use, the control you get by using set_unexpected() is pretty limited, since the handler function is not allowed to return. The only realistic options are to clean up and terminate the program, or to somehow initiate (by some means specific to your host system) a complete restart of your program.

Thanks for the reply..

Originally Posted by grumpy

2) calling set_unexpected() in the constructor of a base class. This works, since base class constructors are guaranteed to be called before derived class constructors.

Is this how the above step is to be done:

Code:

void f()        //Unexpected exception handler
{
    cout<<"Unexpected handler"<<endl;
}
class A            //Base class that performs set_unexpected
{
    unexpected_handler h;
public:
    A()
    {
        h=set_unexpected(f);
    }
    ~A()
    {
        set_unexpected(h);
    }
};
class B:public A    //Derived class that throws unexpected_exception
{
public:
    B() throw ()
    {
        throw 1;
    }
};
B b;
int main()
{
}

It doesn't show the message: "Unexpected handler". I get an exception which is unhandled : System.Runtime.InteropServices.SEHException.

You seem to be using C++/CLI or something, not native C++.
Also, avoid dynamic exception specificers ( throw() ), as they are deprecated and never worked anyway. If you must use something, use noexcept(false) (requires C++11).

The use of a non-local, static object whose constructor can throw, is absolutely insane.