如何：variadic包装函数捕获输入函数的异常

Question

I am trying to create a function that I can pass other functions, which will catch any errors, but otherwise simply return the return value of the function. Here's what I've tried:

#include <iostream>
using namespace std;

int fun(int input)
{
    return input;
}

template <typename F, typename...Args>
static auto HandledCall(const F& function, Args...args)
-> decltype(function(...args))
{
    try
    {
        return function(...args);
    }
    catch(...)
    {
        return NULL;
    }
}

int main() {
    std::cout << HandledCall(fun,1) << std::endl; // this should return 1
    std::cout << HandledCall(fun,-1) << std::endl; // this should return 0      
    return 0;
}

I hope the intention is relatively clear; I want HandledCall to be able to receive any kind of function, and return its return value (as long as NULL is implicitly castable to this value in the case of an error). However, when I try to compile the above code I get these kinds of errors;

prog.cpp:10:78: error: expected primary-expression before '...' token static auto HandledCall(const F& function, Args...args) -> decltype(function(...args))

Clearly I'm not doing this variadic templates thing correctly... Any suggestions?

Answer 1

The return type of the function call can be determined using std::result_of .

template<typename F, typename... Args>
typename std::result_of<F(Args...)>::type
    HandledCall(F&& func, Args&&... args)
{
    using result_type = typename std::result_of<F(Args...)>::type;
    try {
        return std::forward<F>(func)(std::forward<Args>(args)...);
    } catch(...) {
        return result_type();
    }
}

Live demo

Answer 2

Something like this?

#include <iostream>
using namespace std;

int fun(int input)
{
    return input;
}

template <typename T> struct ReturnType;

template<class Ret, class... Args>
struct ReturnType<Ret(Args...)> 
{
   typedef Ret type;
};


template <typename F, typename...Args>
static auto HandledCall(const F& function, Args...args) -> typename ReturnType<F>::type
{
    try
    {
        return function(args...);
    }
    catch(...)
    {
        return typename ReturnType<F>::type{0};
    }
}

int main() {
    std::cout << HandledCall(fun,1) << std::endl; // this should return 1
    std::cout << HandledCall(fun,-1) << std::endl; // this should return 0      
    return 0;
}

Update

An improved version of HandledCall (Thanks to Mankarse):

template <typename F, typename...Args>
static auto HandledCall(const F& function, Args&&...args) -> typename ReturnType<F>::type
{
    try
    {
        return function(std::forward<Args>(args)...);
    }
    catch(...)
    {
        return typename ReturnType<F>::type{0};
    }
}

Answer 3

Here is a version based on the solution presented by @Praetorian but which also works for functions with a void return type. The reason the other answers could not handle this case is the explicit instantiation of an object of type void .

template<typename T> 
T default_value(){return {};}

template<>
void default_value<void>(){}

template<typename F, typename... Args>
typename std::result_of<F(Args...)>::type
  HandledCall(F&& func, Args&&... args)
{
  try {
      return std::forward<F>(func)(std::forward<Args>(args)...);
  } catch(...) {
      return default_value<typename std::result_of<F(Args...)>::type>();
  }
}

The reason this works is because the standard allows explicitly returning void values in a function with void return type.