std::result_of void return 类型失败

Question

我正在尝试使用 SFINAE 创建函数调用包装器，使用 std::result_of 获取函数的 return 类型。重现问题的小样本：

void test(int) {}

template<typename T, typename... Args, typename R = typename std::result_of<T(Args...)>::type, typename std::enable_if<!std::is_void<R>::value, int>::type* = nullptr>
int test2(R& ret_param, Args... args)
{
    T* test_call = test;
    ret_param = test_call(args...);
    return 0;   
}

template<typename T, typename... Args, typename std::enable_if<std::is_void<typename std::result_of<T(Args...)>::type>::value, int>::type* = nullptr>
int test2(Args... args)
{
    T* test_call = test;
    test_call(args...);
    return 0;   
}

int main()
{
  test2<decltype(test)>(1);
}

用 gcc 4.9.2 编译它会导致：

68:26: error: no matching function for call to 'test2(int)'
68:26: note: candidates are:
46:5: note: int test2(R&, Args ...) [with T = void(int); Args = {}; R = int; typename std::enable_if<(! std::is_void<R>::value), int>::type* <anonymous> = 0u]
46:5: note:   no known conversion for argument 1 from 'int' to 'int&'
56:5: note: template<class T, class ... Args, typename std::enable_if<std::is_void<typename std::result_of<_Functor(_ArgTypes ...)>::type>::value, int>::type* <anonymous> > int test2(Args ...)
56:5: note:   template argument deduction/substitution failed:
55:142: error: function returning a function
55:142: note: invalid template non-type parameter

那么问题是 "typename std::result_of::type" 以某种方式评估为函数 returning 函数？如果模板函数的 return 类型无效，使用 SFINAE 强制重载决策选择不同函数的正确方法是什么？值得一提的是，在相反的情况下，测试函数 return 是一个 int。此外，如果 std::is_void 分辨率的 enable_if 被删除，它将在这种情况下工作（但显然，如果存在 return 类型，那么这两个函数将是有效的分辨率，并且编译将失败时它选择了不期望 return 值的那个。

Answer 1

基本上你需要形成 T_ref(Args...) 作为 std::result_of 的参数。

编译如下。我应用了一些简化和重新格式化。

顺便说一句，我认为这不是个好主意。取而代之的是，两个函数的名称不同。毕竟，他们确实需要不同的论据。明确是好的。隐式不好。

#include <type_traits>      // std::(enable_if, result_of)

void test(int) {}
int foo() { return 0; }

template<
    class T,  class R, class... Args,
    class T_ref = T&,
    typename std::enable_if<
        !std::is_void<
            std::result_of_t<T_ref(Args...)>
            >::value
        >::type* = nullptr
    >
int test2(R& ret_param, Args... args)
{
    static_assert( std::is_same<
        R,
        std::result_of_t<T_ref(Args...)>
        >::value, "!" );
    T* test_call = foo;
    ret_param = test_call(args...);
    return 0;
}

template<
    class T, class... Args,
    class T_ref = T&,
    typename std::enable_if<
        std::is_void<
            std::result_of_t<T_ref(Args...)>
            >::value
        >::type* = nullptr
    >
int test2(Args... args)
{
    T* test_call = test;
    test_call(args...);
    return 0;   
}

int main()
{
    test2<decltype(test)>( 1 );

    int result;
    test2<decltype(foo)>( result );
}

Answer 2

如果您接受将测试函数作为参数传递，则不需要所有样板文件：

void test(int) {}
int test(double) { return 0; }

template<typename R, typename... Args>
int test2(R(&f)(Args...), R& ret_param, Args... args)
{
    ret_param = f(args...);
    return 0;   
}

template<typename... Args>
int test2(void(&f)(Args...), Args... args)
{
    f(args...);
    return 0;   
}

int main()
{
    test2(test, 1);
    int r;
    test2(test, r, .0);
}

演绎和重载将为您完成工作。

std::result_of void return 类型失败

std::result_of failing for void return type

c++

sfinae

variadic-templates

c++11