异常安全蹦床的设计模式

这个问题源于here。然而，上一个问题的措辞非常糟糕（实际上是错误的），以至于建议我从头开始再问一次。

我有一个 C 函数指针表。

一些 C 代码（让我们称之为 lib-X）有一个基本构建块（让我们称之为 X 对象）。每个 X 对象都可以调用该表上的函数。

这些表函数通常具有不同的签名（请参阅 typedefhere），尽管多个函数可以共享相同的签名。表中大约有 100 个这样的函数。

在 C++ 中，每个 X 对象都有一个关联的 Final:Base 类。

我想将这些调用转发到 X 对象对应的 C++ Final 实例，但我想将其包含在 try/catch 中，因为 C++ 使用者可能会提供有错误的 Final。

所以我有一个 C++ 基类，它为表中的每个条目都有一个虚函数。

然后我有一个从基类派生的 C++ Final 类（可能有很多；Final1 Final2 Final3 等）。

所以现在我只需要编写一个处理程序

1. 获取第一个“self”参数（它始终是指向调用该函数的 X 对象的指针）

2. 检索关联的 C++ 基类实例。

3. 在 try catch 块内，调用相应的虚函数，通过以下方式转发所有剩余参数：

4. ...这实际上会调用 Final 中的覆盖。

这有点像试图理解《盗梦空间》的情节。 lib-X 实际上是 Python 运行时，尽管我试图保持通用性。

问题是这样的函数有几十个，这会导致一些非常混乱且难以维护的 C++ 代码——如果我必须为每个函数手动编写一个蹦床函数，如下所示：

extern "C" PyObject *call_handler( PyObject *self, PyObject *args, PyObject *kw )
{
    try
    {
        PythonExtensionBase *p = getPythonExtensionBase( self );
        if( kw != NULL )
            return new_reference_to( p->call( Object(args), :Object(kw) ) );
        else
            return new_reference_to( p->call( Object(args), Object() ) );
    }
    catch( Py::Exception & )
    {
        return NULL; // indicate error
    }
}

(source here)

我正在尝试提出一种紧凑的设计，以实现这种异常安全的蹦床运动。

我当前的进度是[已删除，请参阅下面的答案]

像这样的东西？

template<typename RET, class ...Args> // <-- one trap for each f in Base that gets enabled!
RET trap( RET (Base::*f)(Args...), void* self, Args&&...args )
{
    try {
        auto base = reinterpret_cast<Base*>(self);
        return (base->*f)(std::forward<Args>(args)...);
    }
    catch (...) {
        return (RET)0;
    }
}