C++可变参数模板：在GCC和NVCC /英特尔

Question

有下一个代码问题不同的优先级：

#include <iostream> 
#include <functional> 
using namespace std; 

template<typename... Args> 
inline double foo(function<double (Args...)> fun, Args... args) { 
    return fun(args...); 
} 

template<typename... Args, typename... ArgsTmp> 
double foo(function<double (Args...)> fun, ArgsTmp... args) { 
    return foo(fun, 1., args...); 
} 

int main() { 

    function<double (double, double, double)> fun = [&](double x, double y, double z) -> double { 
     return x+y+z; 
    }; 

    cout << foo(fun) << endl; 
} 

当我用gcc编译的一切它去罚款。但是，如果我试图编译它，例如，与英特尔或NVCC-7.5（这实际上是我的目标），我发现了以下错误：

more than one instance of overloaded function "foo" matches the argument list: 
      function template "double foo(std::vector<limits, std::allocator<limits>>, std::function<double (Args...)>, Args...)" 
      function template "double foo(std::vector<limits, std::allocator<limits>>, std::function<double (Args...)>, ArgsTmp...)" 
      argument types are: (std::vector<limits, std::allocator<limits>>, std::function<double (double, double, double)>, double, double, double) 
... 
1 error 

有没有什么办法让编译器知道明确指出当Args==ArgsTmp（在第二个模板中）foo()的下列实现应该被拒绝？

Answer 1

您可以尝试SFINAE和enable_if

template<typename... Args, typename... ArgsTmp> 
std::enable_if_t<!std::is_same<std::tuple<Args...>, 
           std::tuple<ArgsTmp...>>::value, 
       double> 
foo(function<double (Args...)> fun, ArgsTmp... args) { 
    return foo(fun, 1., args...); 
} 

Answer 2

你可以考虑的参数个数：

#include <iostream> 
#include <functional> 
#include <type_traits> 

template<typename... Args> 
inline double foo(std::function<double (Args...)> fun, Args... args) { 
    return fun(args...); 
} 

// Only considered, if the number of arguments is less than the number 
// of expected arguments (accepting any number of arguments may lead 
// to infinite recursion). 
template<typename... Args, typename... ArgsTmp> 
inline typename std::enable_if<sizeof...(ArgsTmp) < sizeof...(Args), double>::type 
foo(std::function<double (Args...)> fun, ArgsTmp... args) { 
    return foo(fun, 1., args...); 
} 

int main() 
{ 
    // A shorter variant 
    std::function<double (double)> fun = [&](double x) -> double { 
     return x; 
    }; 
    std::cout << foo(fun) << std::endl; 
    std::cout << foo(fun, 2.0) << std::endl; 
    // error: no matching function for call to ‘foo(std::function<double(double)>&, double, double)’ 
    // std::cout << foo(fun, 3.0, 4.0) << std::endl; 
}