模板函数接受带有 X 参数的可调用函子

Question

我正在编写一个托管 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。

Answer 1

如果您可以使用 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);

Answer 2

您可以将所有参数绑定到您的函数，使其有效地成为 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);
}