Catching exception thrown by constructor seems impossible

Question

I am working with a library that requires certain functions to be executed to initialize the library and requires that other functions be executed to perform "clean up". To be concrete, the library is OpenGL (with GLFW and GLEW), the initialization functions include glfwInit() and glewInit(), and the cleanup function is glfwTerminate(). The exact library should not matter though.

In the spirit of RAII, I created a LibraryGuard class whose constructor initializes the library and whose destructor calls the necessary cleanup functions.

The library, of course, may fail to initialize. For example, there may not be proper hardware support, dynamic libraries may be missing, etc. To handle these cases, I have defined LibraryGuard's constructor to throw an exception if the library cannot be initialized.

The problem is that I have no idea how to actually catch this exception. The obvious

try {
    LibraryGuard lg;
}
catch () {
    // exit gracefully
}

will not work because LibraryGuard's destructor is called at the end of the try block if lg is successfully created, which means that the library clean-up functions are called.

The only other solutions I can think of are to either 1) not catch the exception; or 2) enclose my entire main function inside a try block. Neither option is particularly palatable.

Answer 1

All points to the right solution being having this try{}catch in your LibraryGuard's constructor, and making sure the library guard actually deals with failing library initialization – that's what you've invented it for!

So, do whatever you need to do when you detect initialization failed in your constructor; then throw the exception to let you main know things went downhill.

Answer 2

What about doing nothing with the constructor and demand the library initialization to a specific method?

Something like

int main ()
 {
   LibraryGuard  lg;  // constructor do nothing

   // ....

   try
    {
      lg.initialize(); // library initialization
    }
   catch (...)
    {
      // case of initialization failure
    }

p.s.: sorry for my bad English.

Answer 3

I think, the question is actually more generic, and the underlying question is about exception policy. What consitutes an exception in your app? To answer this, you need an answer to following questions:

1. What are unrecoverable, invariant-killing errors?
2. At which level you can recover from them?

Now, your OpenGL initialiation failure. I am not your app, but I would imagine, the failure to load OpenGL should be pretty unrecoverable for any application which needed OpenGL in first place. And it seem hard to imagine any level you can recover from that? What would you recover with?

I'd say, (knowing little if anything about your app) your best course of actions is to catch const std::exception& e in main, print e.what() and std::terminate. This is my style, at least.

Answer 4

Your solution is exactly right, but there's a bit missing.

void do_all_my_stuff_with_library() {
    // whatever
}

int main() {
    try {
        LibraryGuard lg;
        do_all_my_stuff_with_library();
    }
    catch () {
        // exit gracefully
    }
    return 0;
}

Answer 5

The clean-up functions need something obtained from the inizialization function?

If it isn't so, you can split your class in 2 classes:

1) a class LibraryIn, that initialize in constructor

2) a class LibratyOut, whose destructor clean-up the library.

So

int main ()
 {
   LibraryOut  lo;  // constructor do nothing

   // ...

   try 
    {
      LibraryIn  li;  // constructor initialize library

      // destructor of li do nothing
    }
   catch (...)
    {
      // in case of library initialization failure
    }

   // ...

   return EXIT_SUCCESS;

   // destructor of lo clean-up the library
 }

Answer 6

You can move-enable your class and use factory function:

LibraryGuard init_library()
{
    try {
        return LibraryGuard{};
    } catch(/*...*/) {
        //Log stuff
        //Terminate application
    }
}

//Usage
auto lg = init_library();

Answer 7

Some sort of pointer:

std::unique_ptr<LibraryGuard> lg;
try {
    lg.reset(new LibraryGuard());
}
catch () {
    // exit gracefully
    lg.release(); // don't know if this is necessary
}

Answer 8

If you can use C++11, you can use std::unique_ptr, so

int main ()
 {
   std::unique_ptr<LibraryGuard>  up;

   try
    {
      up.reset(new LibraryGuard());
    }
   catch (...)
    {
      // in case of library initialization failure
    }

   return 0;

   // destructor of LibraryGuard()
 }

Answer 9

You can do the following, and still adhere to RAII by using std::unique_ptr:

#include <iostream>
#include <memory>

class LoggingLibrary
{
    public:
        LoggingLibrary(int trigger=0) // for demonstration purposes
        { 
           if ( trigger > 0)
               throw "Error"; 
        }
};

using namespace std;

int main() 
{
    unique_ptr<LoggingLibrary> logLib;
    try 
    {
        logLib = make_unique<LoggingLibrary>(0);
    }
    catch(const char *msg)
    {
        cout << msg << " -- Didn't initialize";
    }
    if ( logLib )
    {
        cout << "Hey I'm ok"; // no exception thrown, so you can do work here
    }
}

Live Example (no exception thrown)

Live Example (exception thrown)

The std::unique_ptr will call the destructor of LoggingLibrary when logLib goes out of scope. If there was an exception thrown, the catch block is entered.

But if you take a look at the if (logLib) -- this tests if the smart pointer has an associated object, and there isn't one if an exception was thrown The std::unique_ptr has an operator bool() that handles checking this scenario.

Answer 10

If you are using C-like libraries (GLEW, GLFW) then NO exception is thrown, so the only exceptions you would get are the exceptions you raise yourself, so or you want those exceptions caught in main, or you don't want that exceptions,

the solution is either:

1. Do not throw exceptions if you don't want to handle them, because those C-like libraries will not throw exceptions on their own.
2. You want to throw exceptions, then you have to make sure your object is exception safe

This is the simplest solution (if you want exceptions)

class LibraryGuard{

bool initializedGLFW;
//other flags

     void error(const char* message)}{
          shutDown();
          throw std::exception(message);
     }

public:

     LibraryGuard(){
         initializedGLFW = false;

         if(glfwInit()!=GL_TRUE)
             error("GLFW not initialized");
         initializedGLFW = true;

         //other libraries
     }

     ~LibraryGuard(){
           shutDown();
     }

     void shutDown(){
           //other libraries (order reversed, sometimes order matter)

           if(initializedGLFW){
               initializedGLFW = false;
               glfwTerminate();
           }
     }

}

This way there are no longer problems if destructor is called (it is very RAII way). Basically you want to create an object, if the object is fully initialized then its destructor is called when you quit the "try" block, if the object is partially initialized then the error function wil anyway de-initialize it.

int main(){  

    try{
       LibraryGuard lg;
    }catch( std::exception e){

    }


}

EDIT:

Seems you want to do something like that

//Your new main so you can keep the "lg" alive around ^^
int runApp(){

    LibraryGuard lg;

}

int main(){
    try{
            runApp();
    }catch{

    }
}

Whatever the reason for wich you want to keep the library alive you can still do the following (if that make any sense), do not I'm not saying it is a good idea, still seems the behaviour you want.

int main(){ 
    try{
        LibraryGuard lg;
        // object alive here
        try{
            //other code

        }catch(...){

        }
    }catch(...){

    }

}