一种确保混合 C 和 C++ 时异常传播的机制；代码

Question

我并不是问 C++ 异常通过 C 代码传播是否安全，也不是问发生这种情况时会发生什么。我已阅读 SO(1, < a href="https://stackoverflow.com/questions/6426835/what-happens-if-exception-gets- thrown-through-c-code">2，3) 和 此常见问题解答。我问如何继续：

• 避免向 C 代码泄漏任何 C++ 异常（这意味着在调用 C 代码之前捕获 C++ 领域中的所有异常）
• 还能够捕获 C 代码之外的异常（在更高的 C++ 代码中） 。

让我说明一下我的想法：

假设 libfoo 是一个 C 库，我想在我的 bar C++ 程序中使用它。 libfoo 需要一个我必须提供的回调函数foo_callback。我的回调中使用的函数和方法可能会抛出异常，所以我写道：

void my_callback(void)
{
    try
    {
        // Do processing here.
    }
    catch(...)
    {
        // Catch anything to prevent an exception reaching C code.
        // Fortunately, libfoo provides a foo_error function to
        // signal errors and stop processing.
        foo_error() ;
    }
}

然后我使用我的回调，如下所示：

// The bar program.
int main()
{
    // Use libfoo function to set the desired callback
    foo_set_callback(&my_callback) ;

    // Start processing. This libfoo function uses internally my_callback.
    foo_process() ;

    // Check for errors
    if( foo_ok() )
    {
        // Hurray ! 
    }
    else
    {
        // Something gone wrong.
        // Unfortunately, we lost the exception that caused the error :(
    }
}

我想要的是能够捕获从 my_callback 中抛出的异常main 函数，没有异常通过 libfoo 传播（是的，这是一种量子异常实验 量子隧道通过 C 代码）。

所以我想使用的代码：

void my_callback(void)
{
    try
    {
        // Do processing here.
    }
    catch(...)
    {
        // Catch anything to prevent an exception reaching C code.
        // We save the exception using (the magic) ExceptionHolder.
        ExceptionHolder::Hold() ;

        // Call foo_error function to signal errors and stop processing.
        foo_error() ;
    }
}

// The bar program.
int main()
{
    // Use libfoo function to set the desired callback
    foo_set_callback(&my_callback) ;

    try
    {
        // Start processing. This libfoo function uses internally my_callback.
        foo_process() ;

        // Once gone out of the C land, release any hold exception.
        ExceptionHolder::Release() ;
    }
    catch(exception & e)
    {
        // Something gone wrong.
        // Fortunately, we can handle it in some manner.
    }
    catch( /*something else */ )
    {
    }
    // ...
}

考虑到以下限制：

• libfoo 是源代码封闭的，用 C 编写，并由供应商以编译格式提供。对库进行的测试表明异常无法通过它传播。我无法访问源文件，也无法获得支持异常的编译版本。
• 回调函数大量使用了使用异常的 C++ 代码。所有的错误处理都是围绕异常机制构建的。我决不能简单地使用吞掉所有异常的代码。
• 不涉及多线程。
• 不支持 c++0x。

我的问题：

• 它是否已经被某些库或某些 C++ 魔法（例如 boost），甚至 c++0x 解决了？
• 如果没有，我如何编写一个适用于任何异常类型的 ExceptionHolder？我对 C++ 很满意，但我还没有找到一种方法来编写一个可靠且易于使用的 ExceptionHolder，它适用于任何异常类型。

非常感谢您的任何建议！

---

编辑：我添加了一个响应，其中包含异常保持/释放机制的一些实现。欢迎所有批评或建议。

Answer 1

我相信 boost.exception 有一种机制可以适应您的目的。请参阅此处获取灵感：

http://www.boost。 org/doc/libs/1_47_0/libs/exception/doc/tutorial_exception_ptr.html

它似乎是为了在线程之间传达它们的特殊异常类型，但我认为它几乎是同一件事 - 阻止异常跨线程边界或 C 代码边界传播，将其副本存储在指针后面，然后稍后通过边界另一侧的指针检索它，并可以选择重新抛出它。

我不确定让你自己的异常从 boost 的神奇异常类型派生有多大可行性，但如果我在大约一年前使用它时没记错的话，这是相当合理的。

Answer 2

在 c++11 中，您可以在回调中使用 current_exception() 来设置 exception_ptr 类型的变量，然后当库通知您的调用代码有错误时，使用 rethow_exception()。

这与 c++0x 中用于跨线程传播异常的机制相同。

例子：

---

void foo();                      // C++
extern "C" void bar(void *exp);  // C
void baz(void *exp);             // C++

void foo() {
    std::exception_ptr exp;
    bar(&exp);
    if (exp) {
      std::rethrow_exception(exp);
    }
}

extern "C" void bar(void *exp) {
    baz(exp);
}

void baz(void *exp) {
    try {
        // some code that might throw an exception
        // ...
    } catch (...) { // catch all exceptions, so as to avoid leaking any into the calling C code.
        // capture the exception and make it available to the C++ code above the C code.
        static_cast<std::exception_ptr*>(exp) = std::current_exception();
    }
}

Answer 3

编辑：您可以使用 fungo，这是我在下面描述的想法的更好实现。来自其作者：

fungo 是一个 C++ 库，专为我们这些陷入困境的人而设计使用尚不支持 std::exception_ptr 的较旧 C++ 实现。

换句话说，fungo 允许您公平地尝试存储并稍后重新抛出由 catch(...) 块捕获的异常。这对于跨线程连接或跨 C/C++ 边界接口传播异常很有用。

我会将其标记为答案。

---

正如我在问题中提到的，我现在无法使用 C++0x/11 功能（目前没有计划使用新功能），我将在这里介绍我到目前为止所做的事情：

异常的生命周期跨越try-catcher 块。为了保存异常，必须在堆上创建一个副本。当重新抛出异常时，我们会删除副本。我编写了一个异常持有者接口：

class ExceptionHolderInterface
{
    public :
      ExceptionHolderInterface(void) ;
      virtual ~ExceptionHolderInterface(void) ;
      
      /* For holding an exception. To be called inside a catch block.*/
      virtual void  Hold(void)    = 0 ;

      /* For releasing an exception. To be called inside a try block.*/
      virtual void  Release(void) = 0 ;
    private :
} ;

这是一个类型独立的类。异常类型是使用模板引入的：

template<typename ExceptionType>
class ExceptionHolder : public ExceptionHolderInterface
{
    public :
      ExceptionHolder(void) ;
      virtual ~ExceptionHolder(void) ;

      virtual void Hold(void)
      {
           try
           {
               throw ;
           }
           catch(const ExceptionType & e)
           {
               exception.reset(new ExceptionType(e)) ;
           }
      }

      virtual void Release(void)
      {
          if(exception.get())
          {
              throw ExceptionType(*exception.get()) ;
          }
      }
    private :
      std::auto_ptr<ExceptionType> exception ;
      
      // declare the copy-constructor and the assignment operator here to make the class non-copyable
} ;

我删除了一堆测试/优化/验证，我保留了主要思想。到目前为止，我们已经有了一种类型的异常持有者，因此我们可以构建一个可以同时持有多种类型的异常存储。

class ExceptionStore
{
    public :
      ExceptionStore(void) ;
      ~ExceptionStore(void)
      {
          for(Iterator holder = exception_holders.begin() ; holder != exception_holders.end() ; ++holder)
          {
              delete (*holder) ;
          }
      }

      // Add an exception type to handle
      template<typename ExceptionType>
      void AddExceptionHolder(void)
      {
          exception_holders.push_back(new ExceptionHolder<ExceptionType>()) ; 
      }

      // Try to hold an exception using available holders. Use this inside a catch block.
      void Hold(void)
      {
          Iterator holder = exception_holders.begin() :
          while(holder != exception_holders.end())
          {
              try
              {
                  (*holder)->Hold() ;
                  break ;
              }
              catch(...)
              {
                  ++holder ;
              }
          }
      }

      // Try to release any hold exception. Call this inside a try-block.
      void Release(void)
      {
          Iterator holder = exception_holders.begin() :
          while(holder != exception_holders.end())
          {
              (*holder++)->Release() ;
          }
      }

    private :
      std::list<ExceptionHolderInterface *>  exception_holders ;
      typedef std::list<ExceptionHolderInterface *>::iterator Iterator ;
      
      // Declare the copy-constructor and the assignment operator here to make the class non-copyable
} ;

我可以使用异常存储，如下所示：

// I made a global ExceptionStore just to keep the example simple.
ExceptionStore exception_store ;

void callable_from_c_code(void)
{
    // Normally, we should retrieve the exception store in some manner.
    
    try
    {
        // Do processing here. Exceptions may be thrown.
    }
    catch(...)
    {
        // Something wrong happened. Let's store the error for later.
        exception_store.Hold() ;
    }

    // Exceptions do not propagate to C code. 
} 

int main(int, char * [])
{
    // First, set the exception types we want to handle. The handling is done in
    // the same order as below.
    exception_store.AddExceptionHolder<std::runtime_error>() ;
    exception_store.AddExceptionHolder<std::logic_error>() ;
    exception_store.AddExceptionHolder<MyFancyException>() ;

    // Somehow invoke some C code that uses `callable_from_c_code`
    use_some_c_library_with_callback(&callable_from_c_code) ;

    // Handle any caught exception
    try
    {
        exception_holder.Release() ;
    }
    catch(std::exception &)
    {
        // Something gone wrong ...
    }
    catch(MyFancyException &)
    {
        // Nothing fancy despite the name. We have problems here ...
    }
}

这是非常基本的，并且可能存在一些本示例未处理的意外场景。如果抛出未使用 AddExceptionHolder 声明的类型的异常，则有两种可能性：

• 将基本类型的持有者添加到存储中，因此异常将被捕获并切片，仅保留副本的基本类型。
• 没有一个持有人适合例外，并且它只是丢失了。没有任何事情泄露到C地。

目前，我更喜欢使用此解决方案，而不是经过更多测试/使用/验证的 boost::enable_current_exception 因为我无法重构整个 C++ 代码来包围所有抛出站点boost::enable_current_exception(...)。

不管怎样，std::exception_ptr 似乎是完美的解决方案，一旦我可以转向新的 C++ 标准，我将替换上面的代码。

Answer 4

如果您不准备进行重大重构，您是否能够识别可能引发的异常类型的特定子集？

如果是这样，您可能可以编写一个容器来专门存储每个副本，然后在从 C 调用返回时检索它们。这需要能够复制异常类型。

或者，考虑各种异常的最终解决方案是什么（如果可以的话），并将其打包到某个对象中以便在返回时进行处理。仅当您拥有足够的代码库以了解可能会产生哪些潜在的异常处理时，这才有效。

Hydrid 模型会捕获异常，根据发现的内容创建一个新的异常，然后在从 C 库返回时抛出该异常。