1

我正在编写一个托管的 C++ 程序，它运行用户编写的即时编译的 C 代码。从 C 代码中捕获某些典型异常并进行处理/忽略是绝对重要的。为此，我从结构化异常处理块中调用 C 代码。由于这个块的性质和语义（以及它的调用位置），我已经将实际调用分离到它自己的函数：

    template <typename ret_type, class func>
        static ret_type Cstate::RunProtectedCode(func function) {
            ret_type ret = 0;
            __try {
                ret = function();
            }
            __except(ExceptionHandler(GetExceptionCode(), ExceptionStatus::CSubsystem)) {
                fprintf(stderr, "First chance exception in C-code.\n");
            }
            return ret;
        }

效果很好，因为它应该像这样：

        RunProtectedCode<int>(entry);

但是是否有可能塑造它，以便我可以调用具有可变数量参数的函数 - 也许通过使用一些奇异的函子（唯一的要求显然是它不能有析构函数）？我正在使用 MSVC++ 2010。

4

2 回答 2

3

如果您可以使用 C++11，您可以使用可变参数模板来实现这一点。

template <typename ret_type, class func, typename... Args>
    static ret_type Cstate::RunProtectedCode(func function, Args&&... args) {
        ret_type ret = 0;
        __try {
            ret = function(std::forward<Args>(args)...);
        }
        __except(ExceptionHandler(GetExceptionCode(), ExceptionStatus::CSubsystem)) {
            fprintf(stderr, "First chance exception in C-code.\n");
        }
        return ret;
    }

你可以这样称呼它

RunProtectedCode<int>(entry2, 1, 2);
RunProtectedCode<int>(entry3, 1, "a", 3);

您可以改用 std::function 来简化它（一种）。

template <class func, typename... Args>
    static 
    typename func::result_type Cstate::RunProtectedCode(func function, Args&&... args) {
        typename func::result_type ret = typename func::result_type();
        __try {
            ret = function(std::forward<Args>(args)...);
        }
        __except(ExceptionHandler(GetExceptionCode(), ExceptionStatus::CSubsystem)) {
            fprintf(stderr, "First chance exception in C-code.\n");
        }
        return ret;
    }

你可以这样称呼它

std::function<int(int,int,int)> entry_f = entry;
RunProtectedCode(entry_f,1,2,3);
于 2013-05-16T14:07:03.573 回答
0

您可以将所有参数绑定到您的函数，使其有效地成为 0 元仿函数，例如使用std::bind（在 VC2010 中可用）或boost::bind（我更喜欢这个，因为 VC 实现包含损坏的std::cref）。绑定可以在传递给之前在重载函数中完成RunProtectedCode，例如：

template<typename R>
R(*f)() wrap(R(*f)())
{
    return f;
}

template<typename R, typename A>
boost::function<R(A)> wrap(R(*f)(), A a)
{
    return boost::bind(f, a);
}

template<typename R, typename A1, typename A2>
boost::function<R(A1, A2)> wrap(R(*f)(), A1 a1, A2 a2)
{
    return boost::bind(f, a1, a2);
}
于 2013-05-16T13:55:44.000 回答