捕获构造函数抛出的异常似乎是不可能的

Question

我正在使用一个库，该库需要执行某些函数来初始化库，并且需要执行其他函数来执行“清理”。具体来说，库是OpenGL（带有GLFW和GLEW），初始化函数包括glfwInit()和glewInit()，清理函数是glfwTerminate()。不过，确切的库应该无关紧要。

本着 RAII 的精神，我创建了一个 LibraryGuard 类，其构造函数初始化库，其析构函数调用必要的清理函数。

当然，库可能无法初始化。例如，可能没有适当的硬件支持，可能缺少动态库等。为了处理这些情况，我定义了LibraryGuard的构造函数，如果无法初始化库，则抛出异常。

问题是我不知道如何实际捕获这个异常。显而易见的

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

因为LibraryGuard的析构函数在try块的末尾被调用，如果lg被成功创建，这意味着库清理函数被调用，将不起作用。

我能想到的唯一其他解决方案是 1) 不捕获异常；或 2) 将我的整个 main 函数包含在 try 块中。这两种选择都不是特别可口。

Answer 1

所有这些都表明正确的解决方案是在您的LibraryGuard 的构造函数中包含这个try{}catch，并确保库保护实际上处理失败的库初始化——这就是您发明它的目的！

所以，当您检测到构造函数中的初始化失败时，请执行您需要执行的操作； 然后抛出异常让你main知道事情已经走下坡路了。

Answer 2

不使用构造函数并要求将库初始化为特定方法怎么办？

类似

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

   // ....

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

ps：对不起，我的英语不好。

Answer 3

我认为，这个问题实际上更笼统，根本问题是关于例外政策。什么构成您的应用程序中的异常？要回答这个问题，您需要回答以下问题：

1. 什么是不可恢复、不变量杀死错误？
2. 你可以从他们那里恢复到什么水平？

现在，您的 OpenGL 初始化失败。我不是你的应用程序，但我想，对于首先需要 OpenGL 的任何应用程序，加载 OpenGL 的失败应该是不可恢复的。似乎很难想象你能从中恢复到什么水平？你会用恢复什么？

我想说，（对您的应用知之甚少）您最好的做法是在 main 中捕获 const std::exception& e，打印 e.what() 和 std::terminate。至少这是我的风格。

Answer 4

您的解决方案是完全正确的，但有一点遗漏。

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

清理函数需要从初始化函数中获取一些东西吗？

如果不是这样，您可以将您的班级分成 2 个班级：

1) 一个类 LibraryIn，在构造函数中初始化

2) 一个类 LibratyOut，其析构函数清理库。

所以

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

某种指针：

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

Answer 7

您可以移动启用您的类并使用工厂功能：

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

//Usage
auto lg = init_library();

Answer 8

如果你可以使用C++11，你可以使用std::unique_ptr，所以

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

您可以执行以下操作，并且仍然使用std::unique_ptr 遵守 RAII：

#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)

当logLib 超出范围时，std::unique_ptr 将调用LoggingLibrary 的析构函数。如果抛出异常，则进入catch 块。

但是如果你看一下if (logLib)——这会测试智能指针是否有一个关联的对象，如果抛出异常则没有一个std::unique_ptr有一个operator bool()来处理检查这个场景。

Answer 10

如果您使用的是类 C 库（GLEW、GLFW），则不会引发异常，因此您会得到的唯一异常是您自己提出的异常，或者您希望捕获这些异常在 main 中，或者您不希望出现异常，

解决方案是：

1. 如果您不想处理异常，请不要抛出异常，因为那些 C 类库​​不会自行抛出异常。
2. 你想抛出异常，那么你必须确保你的对象是异常安全的

这是最简单的解决方案（如果你想要例外）

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();
           }
     }

}

如果调用析构函数，这种方式不再有问题（这是非常RAII的方式）。基本上你想创建一个对象，如果对象被完全初始化，那么当你退出“try”块时它的析构函数被调用，如果对象被部分初始化，那么error函数无论如何都会取消初始化它。

int main(){  

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

    }


}

编辑：

看来你想做这样的事

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

    LibraryGuard lg;

}

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

    }
}

无论你想让图书馆保持活力的原因是什么，你仍然可以执行以下操作（如果这有意义的话），我不是说这是一个好主意，看起来仍然是你想要的行为。

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

        }catch(...){

        }
    }catch(...){

    }

}